scikit-learn · jnothman · Feb 16, 2017 · Feb 16, 2017 · Feb 16, 2017 · Feb 16, 2017
diff --git a/sklearn/base.py b/sklearn/base.py
@@ -3,8 +3,9 @@
 # Author: Gael Varoquaux <gael.varoquaux@normalesup.org>
 # License: BSD 3 clause
 
-import copy
+from copy import deepcopy
 import warnings
+import functools
 
 import numpy as np
 from scipy import sparse
@@ -45,11 +46,13 @@ def clone(estimator, safe=True):
     """
     estimator_type = type(estimator)
     # XXX: not handling dictionaries
+    if isinstance(getattr(estimator, 'fit', None), _FrozenFit):
+        return estimator
     if estimator_type in (list, tuple, set, frozenset):
         return estimator_type([clone(e, safe=safe) for e in estimator])
     elif not hasattr(estimator, 'get_params'):
         if not safe:
-            return copy.deepcopy(estimator)
+            return deepcopy(estimator)
         else:
             raise TypeError("Cannot clone object '%s' (type %s): "
                             "it does not seem to be a scikit-learn estimator "
@@ -578,3 +581,51 @@ def is_regressor(estimator):
         True if estimator is a regressor and False otherwise.
     """
     return getattr(estimator, "_estimator_type", None) == "regressor"
+
+
+class _FrozenFit(object):
+    # We use a class as this allows isinstance check in clone
+    def __init__(self, obj):
+        self.obj = obj
+
+    def __call__(self, *args, **kwargs):
+        return self.obj
+
+
+def _frozen_fit_method(obj, method, X, *args, **kwargs):
+    return getattr(obj, method)(X)
+
+
+def freeze(estimator, copy=False):
+    """Copies estimator and freezes it
+
+    Frozen estimators:
+        * have ``fit(self, *args, **kwargs)`` merely return ``self``
+        * have ``fit_transform`` merely perform ``transform``
+        * have ``fit_predict`` merely perform ``predict``
+
+    Parameters
+    ----------
+    estimator : estimator
+    copy : bool
+
+    Returns
+    -------
+    frozen_estimator : estimator
+        A frozen copy of the input estimator, if ``copy``; otherwise, the
+        estimator is mutated to a frozen version of itself.
+
+    Notes
+    -----
+    Only works on estimators with ``__dict__``.
+    """
+    if copy:
+        estimator = deepcopy(estimator)
+    estimator.fit = _FrozenFit(estimator)
+    if hasattr(estimator, 'fit_transform'):
+        estimator.fit_transform = functools.partial(_frozen_fit_method,
+                                                    estimator, 'transform')
+    if hasattr(estimator, 'fit_predict'):
+        estimator.fit_predict = functools.partial(_frozen_fit_method,
+                                                  estimator, 'predict')
+    return estimator
diff --git a/sklearn/tests/test_base.py b/sklearn/tests/test_base.py
@@ -1,6 +1,9 @@
 # Author: Gael Varoquaux
 # License: BSD 3 clause
 
+import sys
+import pickle
+
 import numpy as np
 import scipy.sparse as sp
 
@@ -23,12 +26,13 @@
 
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.tree import DecisionTreeRegressor
+from sklearn.feature_selection import SelectKBest
 from sklearn import datasets
 from sklearn.utils import deprecated
 
 from sklearn.base import TransformerMixin
+from sklearn.base import freeze
 from sklearn.utils.mocking import MockDataFrame
-import pickle
 
 
 #############################################################################
@@ -370,6 +374,43 @@ def test_pickle_version_warning_is_issued_when_no_version_info_in_pickle():
                          tree_pickle_noversion)
 
 
+def test_freeze():
+    X, y = datasets.load_iris(return_X_y=True)
+
+    for copy in [False, True]:
+        est = SelectKBest(k=1).fit(X, y)
+
+        frozen_est = freeze(est, copy=copy)
+        if copy:
+            assert_false(est is frozen_est)
+        else:
+            assert_true(est is frozen_est)
+        assert_array_equal(est.scores_, frozen_est.scores_)
+        assert_true(isinstance(frozen_est, SelectKBest))
+
+        dumped = pickle.dumps(frozen_est)
+        frozen_est2 = pickle.loads(dumped)
+        assert_false(frozen_est is frozen_est2)
+        assert_array_equal(est.scores_, frozen_est2.scores_)
+
+        # scores should be unaffected by new fit
+        assert_true(frozen_est2.fit() is frozen_est2)
+        assert_array_equal(est.scores_, frozen_est2.scores_)
+
+    # Test fit_transform where expected
+    assert_true(hasattr(est, 'fit_transform'))
+    assert_true(hasattr(frozen_est, 'fit_transform'))
+    assert_false(est.fit_transform is frozen_est.fit_transform)
+    frozen_est.fit_transform([np.arange(X.shape[1])], [0])
+    # scores should be unaffected by new fit_transform
+    assert_array_equal(est.scores_, frozen_est.scores_)
+
+    # Test fit_transform not set when not needed
+    est = DecisionTreeClassifier().fit(X, y)
+    frozen_est = freeze(est)
+    assert_false(hasattr(est, 'fit_transform'))
+    assert_false(hasattr(frozen_est, 'fit_transform'))
+
 def test_pickle_version_no_warning_is_issued_with_non_sklearn_estimator():
     iris = datasets.load_iris()
     tree = TreeNoVersion().fit(iris.data, iris.target)
@@ -449,4 +490,4 @@ def test_pickling_works_when_getstate_is_overwritten_in_the_child_class():
     serialized = pickle.dumps(estimator)
     estimator_restored = pickle.loads(serialized)
     assert_equal(estimator_restored.attribute_pickled, 5)
-    assert_equal(estimator_restored._attribute_not_pickled, None)
+    assert_equal(estimator_restored._attribute_not_pickled, None)