scikit-learn · glemaitre · Sep 6, 2017 · Sep 6, 2017 · Sep 6, 2017 · Sep 7, 2017
diff --git a/sklearn/base.py b/sklearn/base.py
@@ -10,6 +10,7 @@
 from scipy import sparse
 from .externals import six
 from .utils.fixes import signature
+from .exceptions import ChangedBehaviorWarning
 from . import __version__
 
 
@@ -26,7 +27,7 @@ def _first_and_last_element(arr):
         return arr[0, 0], arr[-1, -1]
 
 
-def clone(estimator, safe=True):
+def clone(estimator, safe=True, deepcopy=None):
     """Constructs a new estimator with the same parameters.
 
     Clone does a deep copy of the model in an estimator
@@ -39,17 +40,40 @@ def clone(estimator, safe=True):
         The estimator or group of estimators to be cloned
 
     safe : boolean, optional
-        If safe is false, clone will fall back to a deep copy on objects
-        that are not estimators.
+
+        If safe is false, clone will fall back to a copy (deep copy or simple
+        copy depending of the ``deepcopy`` parameter) on objects that are not
+        estimators.
+
+        .. deprecated:: 0.20
+           From 0.22, only a simple copy will be done instead of a deep copy.
+           Use ``deepcopy=True`` to get the previous behavior.
+
+    deepcopy : boolean, optional
+        Whether to make a deep copy or a simple copy of the objects that are
+        not estimators.
+
+        .. versionadded:: 0.20
 
     """
+    if not safe and deepcopy is None:
+        warnings.warn("A simple copy will be performed after 0.22 instead of a"
+                      " deep copy. Set 'deepcopy=True' if you wish to make a"
+                      " deep copy of the parameters which are not estimators.",
+                      ChangedBehaviorWarning)
+        deepcopy = True
+
     estimator_type = type(estimator)
     # XXX: not handling dictionaries
     if estimator_type in (list, tuple, set, frozenset):
-        return estimator_type([clone(e, safe=safe) for e in estimator])
+        return estimator_type([clone(e, safe=safe, deepcopy=deepcopy)
+                               for e in estimator])
     elif not hasattr(estimator, 'get_params'):
         if not safe:
-            return copy.deepcopy(estimator)
+            if deepcopy:
+                return copy.deepcopy(estimator)
+            else:
+                return copy.copy(estimator)
         else:
             raise TypeError("Cannot clone object '%s' (type %s): "
                             "it does not seem to be a scikit-learn estimator "
@@ -58,7 +82,7 @@ def clone(estimator, safe=True):
     klass = estimator.__class__
     new_object_params = estimator.get_params(deep=False)
     for name, param in six.iteritems(new_object_params):
-        new_object_params[name] = clone(param, safe=False)
+        new_object_params[name] = clone(param, safe=False, deepcopy=deepcopy)
     new_object = klass(**new_object_params)
     params_set = new_object.get_params(deep=False)
 

diff --git a/sklearn/calibration.py b/sklearn/calibration.py
@@ -172,7 +172,7 @@ def fit(self, X, y, sample_weight=None):
                     check_consistent_length(y, sample_weight)
                 base_estimator_sample_weight = sample_weight
             for train, test in cv.split(X, y):
-                this_estimator = clone(base_estimator)
+                this_estimator = clone(base_estimator, deepcopy=False)
                 if base_estimator_sample_weight is not None:
                     this_estimator.fit(
                         X[train], y[train],

diff --git a/sklearn/cross_validation.py b/sklearn/cross_validation.py
@@ -1378,7 +1378,9 @@ def cross_val_predict(estimator, X, y=None, cv=None, n_jobs=1,
     # independent, and that it is pickle-able.
     parallel = Parallel(n_jobs=n_jobs, verbose=verbose,
                         pre_dispatch=pre_dispatch)
-    preds_blocks = parallel(delayed(_fit_and_predict)(clone(estimator), X, y,
+    preds_blocks = parallel(delayed(_fit_and_predict)(clone(estimator,
+                                                            deepcopy=False),
+                                                      X, y,
                                                       train, test, verbose,
                                                       fit_params)
                             for train, test in cv)
@@ -1575,7 +1577,8 @@ def cross_val_score(estimator, X, y=None, scoring=None, cv=None, n_jobs=1,
     # independent, and that it is pickle-able.
     parallel = Parallel(n_jobs=n_jobs, verbose=verbose,
                         pre_dispatch=pre_dispatch)
-    scores = parallel(delayed(_fit_and_score)(clone(estimator), X, y, scorer,
+    scores = parallel(delayed(_fit_and_score)(clone(estimator, deepcopy=False),
+                                              X, y, scorer,
                                               train, test, verbose, None,
                                               fit_params)
                       for train, test in cv)
@@ -1942,7 +1945,8 @@ def permutation_test_score(estimator, X, y, cv=None,
 
     # We clone the estimator to make sure that all the folds are
     # independent, and that it is pickle-able.
-    score = _permutation_test_score(clone(estimator), X, y, cv, scorer)
+    score = _permutation_test_score(clone(estimator, deepcopy=False),
+                                    X, y, cv, scorer)
     permutation_scores = Parallel(n_jobs=n_jobs, verbose=verbose)(
         delayed(_permutation_test_score)(
             clone(estimator), X, _shuffle(y, labels, random_state), cv,

diff --git a/sklearn/decomposition/tests/test_nmf.py b/sklearn/decomposition/tests/test_nmf.py
@@ -163,7 +163,7 @@ def test_nmf_sparse_input():
     for solver in ('cd', 'mu'):
         est1 = NMF(solver=solver, n_components=5, init='random',
                    random_state=0, tol=1e-2)
-        est2 = clone(est1)
+        est2 = clone(est1, deepcopy=False)
 
     W1 = est1.fit_transform(A)
     W2 = est2.fit_transform(A_sparse)

diff --git a/sklearn/ensemble/base.py b/sklearn/ensemble/base.py
@@ -122,7 +122,7 @@ def _make_estimator(self, append=True, random_state=None):
         Warning: This method should be used to properly instantiate new
         sub-estimators.
         """
-        estimator = clone(self.base_estimator_)
+        estimator = clone(self.base_estimator_, deepcopy=False)
         estimator.set_params(**dict((p, getattr(self, p))
                                     for p in self.estimator_params))
 

diff --git a/sklearn/ensemble/tests/test_gradient_boosting.py b/sklearn/ensemble/tests/test_gradient_boosting.py
@@ -789,7 +789,7 @@ def test_warm_start_equal_n_estimators():
         est = Cls(n_estimators=100, max_depth=1)
         est.fit(X, y)
 
-        est2 = clone(est)
+        est2 = clone(est, deepcopy=False)
         est2.set_params(n_estimators=est.n_estimators, warm_start=True)
         est2.fit(X, y)
 
@@ -1160,15 +1160,15 @@ def test_gradient_boosting_validation_fraction():
                                      validation_fraction=0.1,
                                      learning_rate=0.1, max_depth=3,
                                      random_state=42)
-    gbc2 = clone(gbc).set_params(validation_fraction=0.3)
-    gbc3 = clone(gbc).set_params(n_iter_no_change=20)
+    gbc2 = clone(gbc, deepcopy=False).set_params(validation_fraction=0.3)
+    gbc3 = clone(gbc, deepcopy=False).set_params(n_iter_no_change=20)
 
     gbr = GradientBoostingRegressor(n_estimators=100, n_iter_no_change=10,
                                     learning_rate=0.1, max_depth=3,
                                     validation_fraction=0.1,
                                     random_state=42)
-    gbr2 = clone(gbr).set_params(validation_fraction=0.3)
-    gbr3 = clone(gbr).set_params(n_iter_no_change=20)
+    gbr2 = clone(gbr, deepcopy=False).set_params(validation_fraction=0.3)
+    gbr3 = clone(gbr, deepcopy=False).set_params(n_iter_no_change=20)
 
     X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
     # Check if validation_fraction has an effect

diff --git a/sklearn/ensemble/voting_classifier.py b/sklearn/ensemble/voting_classifier.py
@@ -193,7 +193,8 @@ def fit(self, X, y, sample_weight=None):
         transformed_y = self.le_.transform(y)
 
         self.estimators_ = Parallel(n_jobs=self.n_jobs)(
-                delayed(_parallel_fit_estimator)(clone(clf), X, transformed_y,
+                delayed(_parallel_fit_estimator)(clone(clf, deepcopy=False),
+                                                 X, transformed_y,
                                                  sample_weight=sample_weight)
                 for clf in clfs if clf is not None)
 

diff --git a/sklearn/feature_extraction/tests/test_text.py b/sklearn/feature_extraction/tests/test_text.py
@@ -980,7 +980,7 @@ def test_tfidfvectorizer_export_idf():
 
 def test_vectorizer_vocab_clone():
     vect_vocab = TfidfVectorizer(vocabulary=["the"])
-    vect_vocab_clone = clone(vect_vocab)
+    vect_vocab_clone = clone(vect_vocab, deepcopy=False)
     vect_vocab.fit(ALL_FOOD_DOCS)
     vect_vocab_clone.fit(ALL_FOOD_DOCS)
     assert_equal(vect_vocab_clone.vocabulary_, vect_vocab.vocabulary_)

diff --git a/sklearn/feature_selection/from_model.py b/sklearn/feature_selection/from_model.py
@@ -165,7 +165,7 @@ def fit(self, X, y=None, **fit_params):
         if self.prefit:
             raise NotFittedError(
                 "Since 'prefit=True', call transform directly")
-        self.estimator_ = clone(self.estimator)
+        self.estimator_ = clone(self.estimator, deepcopy=False)
         self.estimator_.fit(X, y, **fit_params)
         return self
 
@@ -198,6 +198,6 @@ def partial_fit(self, X, y=None, **fit_params):
             raise NotFittedError(
                 "Since 'prefit=True', call transform directly")
         if not hasattr(self, "estimator_"):
-            self.estimator_ = clone(self.estimator)
+            self.estimator_ = clone(self.estimator, deepcopy=False)
         self.estimator_.partial_fit(X, y, **fit_params)
         return self
diff --git a/sklearn/feature_selection/rfe.py b/sklearn/feature_selection/rfe.py
@@ -166,7 +166,7 @@ def _fit(self, X, y, step_score=None):
             features = np.arange(n_features)[support_]
 
             # Rank the remaining features
-            estimator = clone(self.estimator)
+            estimator = clone(self.estimator, deepcopy=False)
             if self.verbose > 0:
                 print("Fitting estimator with %d features." % np.sum(support_))
 
@@ -204,7 +204,7 @@ def _fit(self, X, y, step_score=None):
 
         # Set final attributes
         features = np.arange(n_features)[support_]
-        self.estimator_ = clone(self.estimator)
+        self.estimator_ = clone(self.estimator, deepcopy=False)
         self.estimator_.fit(X[:, features], y)
 
         # Compute step score when only n_features_to_select features left
@@ -450,7 +450,7 @@ def fit(self, X, y):
         self.support_ = rfe.support_
         self.n_features_ = rfe.n_features_
         self.ranking_ = rfe.ranking_
-        self.estimator_ = clone(self.estimator)
+        self.estimator_ = clone(self.estimator, deepcopy=False)
         self.estimator_.fit(self.transform(X), y)
 
         # Fixing a normalization error, n is equal to get_n_splits(X, y) - 1

diff --git a/sklearn/gaussian_process/gpc.py b/sklearn/gaussian_process/gpc.py
@@ -
F438
173,7 +173,7 @@ def fit(self, X, y):
             self.kernel_ = C(1.0, constant_value_bounds="fixed") \
                 * RBF(1.0, length_scale_bounds="fixed")
         else:
-            self.kernel_ = clone(self.kernel)
+            self.kernel_ = clone(self.kernel, deepcopy=False)
 
         self.rng = check_random_state(self.random_state)
 

diff --git a/sklearn/gaussian_process/gpr.py b/sklearn/gaussian_process/gpr.py
@@ -174,7 +174,7 @@ def fit(self, X, y):
             self.kernel_ = C(1.0, constant_value_bounds="fixed") \
                 * RBF(1.0, length_scale_bounds="fixed")
         else:
-            self.kernel_ = clone(self.kernel)
+            self.kernel_ = clone(self.kernel, deepcopy=False)
 
         self._rng = check_random_state(self.random_state)
 

diff --git a/sklearn/gaussian_process/kernels.py b/sklearn/gaussian_process/kernels.py
@@ -200,7 +200,7 @@ def set_params(self, **params):
 
     def clone_with_theta(self, theta):
         """Returns a clone of self with given hyperparameters theta. """
-        cloned = clone(self)
+        cloned = clone(self, deepcopy=False)
         cloned.theta = theta
         return cloned
 

diff --git a/sklearn/gaussian_process/tests/test_kernels.py b/sklearn/gaussian_process/tests/test_kernels.py
@@ -195,7 +195,7 @@ def check_hyperparameters_equal(kernel1, kernel2):
 def test_kernel_clone():
     # Test that sklearn's clone works correctly on kernels.
     for kernel in kernels:
-        kernel_cloned = clone(kernel)
+        kernel_cloned = clone(kernel, deepcopy=False)
 
         # XXX: Should this be fixed?
         # This differs from the sklearn's estimators equality check.
@@ -218,7 +218,7 @@ def test_kernel_clone_after_set_params():
     # for more details.
     bounds = (1e-5, 1e5)
     for kernel in kernels:
-        kernel_cloned = clone(kernel)
+        kernel_cloned = clone(kernel, deepcopy=False)
         params = kernel.get_params()
         # RationalQuadratic kernel is isotropic.
         isotropic_kernels = (ExpSineSquared, RationalQuadratic)
@@ -232,7 +232,7 @@ def test_kernel_clone_after_set_params():
                 params['length_scale'] = [length_scale] * 2
                 params['length_scale_bounds'] = bounds * 2
             kernel_cloned.set_params(**params)
-            kernel_cloned_clone = clone(kernel_cloned)
+            kernel_cloned_clone = clone(kernel_cloned, deepcopy=False)
             assert_equal(kernel_cloned_clone.get_params(),
                          kernel_cloned.get_params())
             assert_not_equal(id(kernel_cloned_clone), id(kernel_cloned))

diff --git a/sklearn/grid_search.py b/sklearn/grid_search.py
@@ -559,15 +559,16 @@ def _fit(self, X, y, parameter_iterable):
                       " {2} fits".format(len(cv), n_candidates,
                                          n_candidates * len(cv)))
 
-        base_estimator = clone(self.estimator)
+        base_estimator = clone(self.estimator, deepcopy=False)
 
         pre_dispatch = self.pre_dispatch
 
         out = Parallel(
             n_jobs=self.n_jobs, verbose=self.verbose,
             pre_dispatch=pre_dispatch
         )(
-            delayed(_fit_and_score)(clone(base_estimator), X, y, self.scorer_,
+            delayed(_fit_and_score)(clone(base_estimator, deepcopy=False),
+                                    X, y, self.scorer_,
                                     train, test, self.verbose, parameters,
                                     self.fit_params, return_parameters=True,
                                     error_score=self.error_score)
@@ -614,7 +615,7 @@ def _fit(self, X, y, parameter_iterable):
         if self.refit:
             # fit the best estimator using the entire dataset
             # clone first to work around broken estimators
-            best_estimator = clone(base_estimator).set_params(
+            best_estimator = clone(base_estimator, deepcopy=False).set_params(
                 **best.parameters)
             if y is not None:
                 best_estimator.fit(X, y, **self.fit_params)

diff --git a/sklearn/learning_curve.py b/sklearn/learning_curve.py
@@ -161,11 +161,13 @@ def learning_curve(estimator, X, y, train_sizes=np.linspace(0.1, 1.0, 5),
     if exploit_incremental_learning:
         classes = np.unique(y) if is_classifier(estimator) else None
         out = parallel(delayed(_incremental_fit_estimator)(
-            clone(estimator), X, y, classes, train, test, train_sizes_abs,
+            clone(estimator, deepcopy=False), X, y, classes,
+            train, test, train_sizes_abs,
             scorer, verbose) for train, test in cv)
     else:
         out = parallel(delayed(_fit_and_score)(
-            clone(estimator), X, y, scorer, train[:n_train_samples], test,
+            clone(estimator, deepcopy=False), X, y, scorer,
+            train[:n_train_samples], test,
             verbose, parameters=None, fit_params=None, return_train_score=True,
             error_score=error_score)
             for train, test in cv for n_train_samples in train_sizes_abs)
@@ -348,7 +350,7 @@ def validation_curve(estimator, X, y, param_name, param_range, cv=None,
     parallel = Parallel(n_jobs=n_jobs, pre_dispatch=pre_dispatch,
                         verbose=verbose)
     out = parallel(delayed(_fit_and_score)(
-        clone(estimator), X, y, scorer, train, test, verbose,
+        clone(estimator, deepcopy=False), X, y, scorer, train, test, verbose,
         parameters={param_name: v}, fit_params=None, return_train_score=True)
         for train, test in cv for v in param_range)
 

diff --git a/sklearn/linear_model/ransac.py b/sklearn/linear_model/ransac.py
@@ -251,7 +251,7 @@ def fit(self, X, y, sample_weight=None):
         check_consistent_length(X, y)
 
         if self.base_estimator is not None:
-            base_estimator = clone(self.base_estimator)
+            base_estimator = clone(self.base_estimator, deepcopy=False)
         else:
             base_estimator = LinearRegression()