[MRG + 1] ENH add check_inverse in FunctionTransformer

doc/modules/preprocessing.rst

@@ -610,6 +610,9 @@ a transformer that applies a log transformation in a pipeline, do::
     array([[ 0.        ,  0.69314718],
            [ 1.09861229,  1.38629436]])
 
+We can ensure that ``func`` and ``inverse_func`` are the inverse of each other
+by setting ``check_inverse=True``.
+
 For a full code example that demonstrates using a :class:`FunctionTransformer`
 to do custom feature selection,
 see :ref:`sphx_glr_auto_examples_preprocessing_plot_function_transformer.py`

doc/whats_new.rst

@@ -5,11 +5,25 @@
 Release history
 ===============
 
-Version 0.19
+Version 0.20
 ============
 
 **In Development**
 
+Changelog
+---------
+
+Enhancements
+............
+
+    - A parameter ``check_inverse`` was added to :class:`FunctionTransformer`
+      to ensure that ``func`` and ``inverse_func`` are the inverse of each
+      other.
+      :issue:`9399` by :user:`Guillaume Lemaitre <glemaitre>`.
+
+Version 0.19
+============
+
 Highlights
 ----------
 
@@ -490,7 +504,7 @@ Decomposition, manifold learning and clustering
      in :class:`decomposition.PCA`,
      :class:`decomposition.RandomizedPCA` and
      :class:`decomposition.IncrementalPCA`.
-     :issue:`9105` by `Hanmin Qin <https://github.com/qinhanmin2014>`_. 
+     :issue:`9105` by `Hanmin Qin <https://github.com/qinhanmin2014>`_.
 
    - Fixed a bug where :class:`cluster.DBSCAN` gives incorrect
      result when input is a precomputed sparse matrix with initial

sklearn/preprocessing/_function_transformer.py

@@ -1,7 +1,8 @@
 import warnings
 
 from ..base import BaseEstimator, TransformerMixin
-from ..utils import check_array
+from ..utils import check_array, check_random_state, safe_indexing
+from ..utils.testing import assert_allclose_dense_sparse
 from ..externals.six import string_types
 
 
@@ -59,23 +60,59 @@ class FunctionTransformer(BaseEstimator, TransformerMixin):
 
         .. deprecated::0.19
 
+    check_inverse : bool, (default=False)
+       Whether to check that ``transform`` followed by ``inverse_transform``
+       or ``func`` followed by ``inverse_func`` leads to the original inputs.
+
+       .. versionadded:: 0.20
+
     kw_args : dict, optional
         Dictionary of additional keyword arguments to pass to func.
 
     inv_kw_args : dict, optional
         Dictionary of additional keyword arguments to pass to inverse_func.
 
+    random_state : int, RandomState instance or None, optional (default=None)
+        If int, random_state is the seed used by the random number generator;
+        If RandomState instance, random_state is the random number generator;
+        If None, the random number generator is the RandomState instance used
+        by np.random. Note that this is used to compute if func and
+        inverse_func are the inverse of each other.
+
+
     """
     def __init__(self, func=None, inverse_func=None, validate=True,
-                 accept_sparse=False, pass_y='deprecated',
-                 kw_args=None, inv_kw_args=None):
+                 accept_sparse=False, pass_y='deprecated', check_inverse=False,
+                 kw_args=None, inv_kw_args=None, random_state=None):
         self.func = func
         self.inverse_func = inverse_func
         self.validate = validate
         self.accept_sparse = accept_sparse
         self.pass_y = pass_y
+        self.check_inverse = check_inverse
         self.kw_args = kw_args
         self.inv_kw_args = inv_kw_args
+        self.random_state = random_state
+
+    def _validate_inverse(self, X):
+        """Check that func and inverse_func are the inverse."""
+        random_state = check_random_state(self.random_state)
+        n_subsample = min(100, X.shape[0])
+        subsample_idx = random_state.choice(range(X.shape[0]),
+                                            size=n_subsample,
+                                            replace=False)
+
+        X_sel = safe_indexing(X, subsample_idx)
+        print(subsample_idx)
+        try:
+            assert_allclose_dense_sparse(
+                X_sel, self.inverse_transform(self.transform(X_sel)),
+                atol=1e-7)
+        except AssertionError:
+            raise ValueError("The provided functions are not strictly"
+                             " inverse of each other. If you are sure you"
+                             " want to proceed regardless, set"
+                             " 'check_inverse=False'")
 
     def fit(self, X, y=None):
         """Fit transformer by checking X.
@@ -93,6 +130,8 @@ def fit(self, X, y=None):
         """
         if self.validate:
             check_array(X, self.accept_sparse)
+        if self.check_inverse:
+            self._validate_inverse(X)
         return self
 
     def transform(self, X, y='deprecated'):

sklearn/preprocessing/tests/test_function_transformer.py

@@ -1,8 +1,10 @@
 import numpy as np
+from scipy import sparse
 
 from sklearn.preprocessing import FunctionTransformer
-from sklearn.utils.testing import assert_equal, assert_array_equal
-from sklearn.utils.testing import assert_warns_message
+from sklearn.utils.testing import (assert_equal, assert_array_equal,
+                                   assert_allclose_dense_sparse)
+from sklearn.utils.testing import assert_warns_message, assert_raises_regex
 
 
 def _make_func(args_store, kwargs_store, func=lambda X, *a, **k: X):
@@ -126,3 +128,33 @@ def test_inverse_transform():
         F.inverse_transform(F.transform(X)),
         np.around(np.sqrt(X), decimals=3),
     )
+
+
+def test_check_inverse():
+    X_dense = np.array([1, 4, 9, 16], dtype=np.float64).reshape((2, 2))
+
+    X_list = [X_dense,
+              sparse.csr_matrix(X_dense),
+              sparse.csc_matrix(X_dense)]
+
+    for X in X_list:
+        print(X)
+        if sparse.issparse(X):
+            accept_sparse = True
+        else:
+            accept_sparse = False
+        trans = FunctionTransformer(func=np.sqrt,
+                                    inverse_func=np.around,
+                                    accept_sparse=accept_sparse,
+                                    check_inverse=True)
+        assert_raises_regex(ValueError, "The provided functions are not"
+                            " strictly inverse of each other. If you are sure"
+                            " you want to proceed regardless, set"
+                            " 'check_inverse=False'",
+                            trans.fit, X)
+        trans = FunctionTransformer(func=np.expm1,
+                                    inverse_func=np.log1p,
+                                    accept_sparse=accept_sparse,
+                                    check_inverse=True)
+        Xt = trans.fit_transform(X)
+        assert_allclose_dense_sparse(X, trans.inverse_transform(Xt))