[MRG+1] Option to suppress validation for finiteness (scikit-learn#7548)

* ENH add suppress validation option

* TST skip problematic doctest

* Rename SUPPRESS_VALIDATION to PRESUME_FINITE

* Change PRESUME_ to ASSUME_ for convention's sake

* DOC add note regarding assert_all_finite

* ENH add set_config context manager for ASSUME_FINITE

* Make ASSUME_FINITE private and provide get_config

* Fix ImportError due to incomplete change in last commit

* TST/DOC tests and more cautious documentation for set_config

* DOC what's new entry for validation suppression

* context manager is now config_context; set_config affects global config

* Rename missed set_config to config_context

* Fix mis-named test

* Mention set_config in narrative docs

* More explicit about limmited restoration of context

* Handle case where error raised in config_context

* Reset all settings after exiting context manager

Author: jnothman

doc/modules/classes.rst

@@ -40,6 +40,9 @@ Functions
    :template: function.rst
 
    base.clone
+   config_context
+   set_config
+   get_config
 
 
 .. _cluster_ref:

doc/modules/computational_performance.rst

@@ -68,6 +68,25 @@ To benchmark different estimators for your case you can simply change the
 :ref:`sphx_glr_auto_examples_applications_plot_prediction_latency.py`. This should give
 you an estimate of the order of magnitude of the prediction latency.
 
+.. topic:: Configuring Scikit-learn for reduced validation overhead
+
+    Scikit-learn does some validation on data that increases the overhead per
+    call to ``predict`` and similar functions. In particular, checking that
+    features are finite (not NaN or infinite) involves a full pass over the
+    data. If you ensure that your data is acceptable, you may suppress
+    checking for finiteness by setting the environment variable
+    ``SKLEARN_ASSUME_FINITE`` to a non-empty string before importing
+    scikit-learn, or configure it in Python with :func:`sklearn.set_config`.
+    For more control than these global settings, a :func:`config_context`
+    allows you to set this configuration within a specified context::
+
+      >>> import sklearn
+      >>> with sklearn.config_context(assume_finite=True):
+      ...    pass  # do learning/prediction here with reduced validation
+
+    Note that this will affect all uses of
+    :func:`sklearn.utils.assert_all_finite` within the context.
+
 Influence of the Number of Features
 -----------------------------------
 

doc/whats_new.rst

@@ -31,6 +31,11 @@ Changelog
 New features
 ............
 
+   - Validation that input data contains no NaN or inf can now be suppressed
+     using :func:`config_context`, at your own risk. This will save on runtime,
+     and may be particularly useful for prediction time. :issue:`7548` by
+     `Joel Nothman`_.
+
    - Added the :class:`neighbors.LocalOutlierFactor` class for anomaly
      detection based on nearest neighbors.
      :issue:`5279` by `Nicolas Goix`_ and `Alexandre Gramfort`_.

sklearn/__init__.py

@@ -15,6 +15,78 @@
 import sys
 import re
 import warnings
+import os
+from contextlib import contextmanager as _contextmanager
+
+_ASSUME_FINITE = bool(os.environ.get('SKLEARN_ASSUME_FINITE', False))
+
+
+def get_config():
+    """Retrieve current values for configuration set by :func:`set_config`
+
+    Returns
+    -------
+    config : dict
+        Keys are parameter names that can be passed to :func:`set_config`.
+    """
+    return {'assume_finite': _ASSUME_FINITE}
+
+
+def set_config(assume_finite=None):
+    """Set global scikit-learn configuration
+
+    Parameters
+    ----------
+    assume_finite : bool, optional
+        If True, validation for finiteness will be skipped,
+        saving time, but leading to potential crashes. If
+        False, validation for finiteness will be performed,
+        avoiding error.
+    """
+    global _ASSUME_FINITE
+    if assume_finite is not None:
+        _ASSUME_FINITE = assume_finite
+
+
+@_contextmanager
+def config_context(**new_config):
+    """Context manager for global scikit-learn configuration
+
+    Parameters
+    ----------
+    assume_finite : bool, optional
+        If True, validation for finiteness will be skipped,
+        saving time, but leading to potential crashes. If
+        False, validation for finiteness will be performed,
+        avoiding error.
+
+    Notes
+    -----
+    All settings, not just those presently modified, will be returned to
+    their previous values when the context manager is exited. This is not
+    thread-safe.
+
+    Examples
+    --------
+    >>> import sklearn
+    >>> from sklearn.utils.validation import assert_all_finite
+    >>> with sklearn.config_context(assume_finite=True):
+    ...     assert_all_finite([float('nan')])
+    >>> with sklearn.config_context(assume_finite=True):
+    ...     with sklearn.config_context(assume_finite=False):
+    ...         assert_all_finite([float('nan')])
+    ... # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    ValueError: Input contains NaN, ...
+    """
+    old_config = get_config().copy()
+    set_config(**new_config)
+
+    try:
+        yield
+    finally:
+        set_config(**old_config)
 
 
 # Make sure that DeprecationWarning within this package always gets printed

sklearn/tests/test_config.py

@@ -0,0 +1,68 @@
+from sklearn import get_config, set_config, config_context
+from sklearn.utils.testing import assert_equal, assert_raises
+
+
+def test_config_context():
+    assert_equal(get_config(), {'assume_finite': False})
+
+    # Not using as a context manager affects nothing
+    config_context(assume_finite=True)
+    assert_equal(get_config(), {'assume_finite': False})
+
+    with config_context(assume_finite=True):
+        assert_equal(get_config(), {'assume_finite': True})
+    assert_equal(get_config(), {'assume_finite': False})
+
+    with config_context(assume_finite=True):
+        with config_context(assume_finite=None):
+            assert_equal(get_config(), {'assume_finite': True})
+
+        assert_equal(get_config(), {'assume_finite': True})
+
+        with config_context(assume_finite=False):
+            assert_equal(get_config(), {'assume_finite': False})
+
+            with config_context(assume_finite=None):
+                assert_equal(get_config(), {'assume_finite': False})
+
+                # global setting will not be retained outside of context that
+                # did not modify this setting
+                set_config(assume_finite=True)
+                assert_equal(get_config(), {'assume_finite': True})
+
+            assert_equal(get_config(), {'assume_finite': False})
+
+        assert_equal(get_config(), {'assume_finite': True})
+
+    assert_equal(get_config(), {'assume_finite': False})
+
+    # No positional arguments
+    assert_raises(TypeError, config_context, True)
+    # No unknown arguments
+    assert_raises(TypeError, config_context(do_something_else=True).__enter__)
+
+
+def test_config_context_exception():
+    assert_equal(get_config(), {'assume_finite': False})
+    try:
+        with config_context(assume_finite=True):
+            assert_equal(get_config(), {'assume_finite': True})
+            raise ValueError()
+    except ValueError:
+        pass
+    assert_equal(get_config(), {'assume_finite': False})
+
+
+def test_set_config():
+    assert_equal(get_config(), {'assume_finite': False})
+    set_config(assume_finite=None)
+    assert_equal(get_config(), {'assume_finite': False})
+    set_config(assume_finite=True)
+    assert_equal(get_config(), {'assume_finite': True})
+    set_config(assume_finite=None)
+    assert_equal(get_config(), {'assume_finite': True})
+    set_config(assume_finite=False)
+    assert_equal(get_config(), {'assume_finite': False})
+
+    # No unknown arguments
+    assert_raises(TypeError, set_config, do_something_else=True)

sklearn/utils/tests/test_validation.py

@@ -30,14 +30,15 @@
     has_fit_parameter,
     check_is_fitted,
     check_consistent_length,
+    assert_all_finite,
 )
+import sklearn
 
 from sklearn.exceptions import NotFittedError
 from sklearn.exceptions import DataConversionWarning
 
 from sklearn.utils.testing import assert_raise_message
 
-
 def test_as_float_array():
     # Test function for as_float_array
     X = np.ones((3, 10), dtype=np.int32)
@@ -526,3 +527,12 @@ def test_check_dataframe_fit_attribute():
         check_consistent_length(X_df)
     except ImportError:
         raise SkipTest("Pandas not found")
+
+
+def test_suppress_validation():
+    X = np.array([0, np.inf])
+    assert_raises(ValueError, assert_all_finite, X)
+    sklearn.set_config(assume_finite=True)
+    assert_all_finite(X)
+    sklearn.set_config(assume_finite=False)
+    assert_raises(ValueError, assert_all_finite, X)

sklearn/utils/validation.py

@@ -16,6 +16,7 @@
 
 from ..externals import six
 from ..utils.fixes import signature
+from .. import get_config as _get_config
 from ..exceptions import NonBLASDotWarning
 from ..exceptions import NotFittedError
 from ..exceptions import DataConversionWarning
@@ -30,6 +31,8 @@
 
 def _assert_all_finite(X):
     """Like assert_all_finite, but only for ndarray."""
+    if _get_config()['assume_finite']:
+        return
     X = np.asanyarray(X)
     # First try an O(n) time, O(1) space solution for the common case that
     # everything is finite; fall back to O(n) space np.isfinite to prevent