iter

Author: glemaitre

imblearn/pipeline.py

@@ -2,6 +2,7 @@
 The :mod:`imblearn.pipeline` module implements utilities to build a
 composite estimator, as a chain of transforms, samples and estimators.
 """
+
 # Adapted from scikit-learn
 
 # Author: Edouard Duchesnay
@@ -12,13 +13,18 @@
 #         Christos Aridas
 #         Guillaume Lemaitre <[email protected]>
 # License: BSD
+import warnings
+from contextlib import contextmanager
+from copy import deepcopy
+
 import sklearn
 from sklearn import pipeline
 from sklearn.base import clone
+from sklearn.exceptions import NotFittedError
 from sklearn.utils import Bunch
 from sklearn.utils.fixes import parse_version
 from sklearn.utils.metaestimators import available_if
-from sklearn.utils.validation import check_memory
+from sklearn.utils.validation import check_memory, check_is_fitted
 
 from .base import _ParamsValidationMixin
 from .utils._metadata_requests import (
@@ -30,7 +36,7 @@
     process_routing,
 )
 from .utils._param_validation import HasMethods, validate_params
-from .utils.fixes import _fit_context
+from .utils.fixes import _fit_context, get_tags
 
 METHODS.append("fit_resample")
 
@@ -43,6 +49,31 @@
     from sklearn.utils._user_interface import _print_elapsed_time
 
 
+@contextmanager
+def _raise_or_warn_if_not_fitted(estimator):
+    """A context manager to make sure a NotFittedError is raised, if a sub-estimator
+    raises the error.
+    Otherwise, we raise a warning if the pipeline is not fitted, with the deprecation.
+    TODO(1.8): remove this context manager and replace with check_is_fitted.
+    """
+    try:
+        yield
+    except NotFittedError as exc:
+        raise NotFittedError("Pipeline is not fitted yet.") from exc
+
+    # we only get here if the above didn't raise
+    try:
+        check_is_fitted(estimator)
+    except NotFittedError:
+        warnings.warn(
+            "This Pipeline instance is not fitted yet. Call 'fit' with "
+            "appropriate arguments before using other methods such as transform, "
+            "predict, etc. This will raise an error in 1.8 instead of the current "
+            "warning.",
+            FutureWarning,
+        )
+
+
 class Pipeline(_ParamsValidationMixin, pipeline.Pipeline):
     """Pipeline of transforms and resamples with a final estimator.
 
@@ -456,18 +487,22 @@ def predict(self, X, **params):
         y_pred : ndarray
             Result of calling `predict` on the final estimator.
         """
-        Xt = X
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            Xt = X
 
-        if not _routing_enabled():
-            for _, name, transform in self._iter(with_final=False):
-                Xt = transform.transform(Xt)
-            return self.steps[-1][1].predict(Xt, **params)
+            if not _routing_enabled():
+                for _, name, transform in self._iter(with_final=False):
+                    Xt = transform.transform(Xt)
+                return self.steps[-1][1].predict(Xt, **params)
 
-        # metadata routing enabled
-        routed_params = process_routing(self, "predict", **params)
-        for _, name, transform in self._iter(with_final=False):
-            Xt = transform.transform(Xt, **routed_params[name].transform)
-        return self.steps[-1][1].predict(Xt, **routed_params[self.steps[-1][0]].predict)
+            # metadata routing enabled
+            routed_params = process_routing(self, "predict", **params)
+            for _, name, transform in self._iter(with_final=False):
+                Xt = transform.transform(Xt, **routed_params[name].transform)
+            return self.steps[-1][1].predict(
+                Xt, **routed_params[self.steps[-1][0]].predict
+            )
 
     def _can_fit_resample(self):
         return self._final_estimator == "passthrough" or hasattr(
@@ -646,20 +681,22 @@ def predict_proba(self, X, **params):
         y_proba : ndarray of shape (n_samples, n_classes)
             Result of calling `predict_proba` on the final estimator.
         """
-        Xt = X
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            Xt = X
+
+            if not _routing_enabled():
+                for _, name, transform in self._iter(with_final=False):
+                    Xt = transform.transform(Xt)
+                return self.steps[-1][1].predict_proba(Xt, **params)
 
-        if not _routing_enabled():
+            # metadata routing enabled
+            routed_params = process_routing(self, "predict_proba", **params)
             for _, name, transform in self._iter(with_final=False):
-                Xt = transform.transform(Xt)
-            return self.steps[-1][1].predict_proba(Xt, **params)
-
-        # metadata routing enabled
-        routed_params = process_routing(self, "predict_proba", **params)
-        for _, name, transform in self._iter(with_final=False):
-            Xt = transform.transform(Xt, **routed_params[name].transform)
-        return self.steps[-1][1].predict_proba(
-            Xt, **routed_params[self.steps[-1][0]].predict_proba
-        )
+                Xt = transform.transform(Xt, **routed_params[name].transform)
+            return self.steps[-1][1].predict_proba(
+                Xt, **routed_params[self.steps[-1][0]].predict_proba
+            )
 
     @available_if(pipeline._final_estimator_has("decision_function"))
     def decision_function(self, X, **params):
@@ -691,20 +728,23 @@ def decision_function(self, X, **params):
         y_score : ndarray of shape (n_samples, n_classes)
             Result of calling `decision_function` on the final estimator.
         """
-        _raise_for_params(params, self, "decision_function")
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            _raise_for_params(params, self, "decision_function")
 
-        # not branching here since params is only available if
-        # enable_metadata_routing=True
-        routed_params = process_routing(self, "decision_function", **params)
+            # not branching here since params is only available if
+            # enable_metadata_routing=True
+            routed_params = process_routing(self, "decision_function", **params)
 
-        Xt = X
-        for _, name, transform in self._iter(with_final=False):
-            Xt = transform.transform(
-                Xt, **routed_params.get(name, {}).get("transform", {})
+            Xt = X
+            for _, name, transform in self._iter(with_final=False):
+                Xt = transform.transform(
+                    Xt, **routed_params.get(name, {}).get("transform", {})
+                )
+            return self.steps[-1][1].decision_function(
+                Xt,
+                **routed_params.get(self.steps[-1][0], {}).get("decision_function", {}),
             )
-        return self.steps[-1][1].decision_function(
-            Xt, **routed_params.get(self.steps[-1][0], {}).get("decision_function", {})
-        )
 
     @available_if(pipeline._final_estimator_has("score_samples"))
     def score_samples(self, X):
@@ -726,10 +766,12 @@ def score_samples(self, X):
         y_score : ndarray of shape (n_samples,)
             Result of calling `score_samples` on the final estimator.
         """
-        Xt = X
-        for _, _, transformer in self._iter(with_final=False):
-            Xt = transformer.transform(Xt)
-        return self.steps[-1][1].score_samples(Xt)
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            Xt = X
+            for _, _, transformer in self._iter(with_final=False):
+                Xt = transformer.transform(Xt)
+            return self.steps[-1][1].score_samples(Xt)
 
     @available_if(pipeline._final_estimator_has("predict_log_proba"))
     def predict_log_proba(self, X, **params):
@@ -773,20 +815,22 @@ def predict_log_proba(self, X, **params):
         y_log_proba : ndarray of shape (n_samples, n_classes)
             Result of calling `predict_log_proba` on the final estimator.
         """
-        Xt = X
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            Xt = X
 
-        if not _routing_enabled():
+            if not _routing_enabled():
+                for _, name, transform in self._iter(with_final=False):
+                    Xt = transform.transform(Xt)
+                return self.steps[-1][1].predict_log_proba(Xt, **params)
+
+            # metadata routing enabled
+            routed_params = process_routing(self, "predict_log_proba", **params)
             for _, name, transform in self._iter(with_final=False):
-                Xt = transform.transform(Xt)
-            return self.steps[-1][1].predict_log_proba(Xt, **params)
-
-        # metadata routing enabled
-        routed_params = process_routing(self, "predict_log_proba", **params)
-        for _, name, transform in self._iter(with_final=False):
-            Xt = transform.transform(Xt, **routed_params[name].transform)
-        return self.steps[-1][1].predict_log_proba(
-            Xt, **routed_params[self.steps[-1][0]].predict_log_proba
-        )
+                Xt = transform.transform(Xt, **routed_params[name].transform)
+            return self.steps[-1][1].predict_log_proba(
+                Xt, **routed_params[self.steps[-1][0]].predict_log_proba
+            )
 
     def _can_transform(self):
         return self._final_estimator == "passthrough" or hasattr(
@@ -826,15 +870,17 @@ def transform(self, X, **params):
         Xt : ndarray of shape (n_samples, n_transformed_features)
             Transformed data.
         """
-        _raise_for_params(params, self, "transform")
-
-        # not branching here since params is only available if
-        # enable_metadata_routing=True
-        routed_params = process_routing(self, "transform", **params)
-        Xt = X
-        for _, name, transform in self._iter():
-            Xt = transform.transform(Xt, **routed_params[name].transform)
-        return Xt
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            _raise_for_params(params, self, "transform")
+
+            # not branching here since params is only available if
+            # enable_metadata_routing=True
+            routed_params = process_routing(self, "transform", **params)
+            Xt = X
+            for _, name, transform in self._iter():
+                Xt = transform.transform(Xt, **routed_params[name].transform)
+            return Xt
 
     def _can_inverse_transform(self):
         return all(hasattr(t, "inverse_transform") for _, _, t in self._iter())
@@ -869,17 +915,19 @@ def inverse_transform(self, Xt, **params):
             Inverse transformed data, that is, data in the original feature
             space.
         """
-        _raise_for_params(params, self, "inverse_transform")
-
-        # we don't have to branch here, since params is only non-empty if
-        # enable_metadata_routing=True.
-        routed_params = process_routing(self, "inverse_transform", **params)
-        reverse_iter = reversed(list(self._iter()))
-        for _, name, transform in reverse_iter:
-            Xt = transform.inverse_transform(
-                Xt, **routed_params[name].inverse_transform
-            )
-        return Xt
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            _raise_for_params(params, self, "inverse_transform")
+
+            # we don't have to branch here, since params is only non-empty if
+            # enable_metadata_routing=True.
+            routed_params = process_routing(self, "inverse_transform", **params)
+            reverse_iter = reversed(list(self._iter()))
+            for _, name, transform in reverse_iter:
+                Xt = transform.inverse_transform(
+                    Xt, **routed_params[name].inverse_transform
+                )
+            return Xt
 
     @available_if(pipeline._final_estimator_has("score"))
     def score(self, X, y=None, sample_weight=None, **params):
@@ -918,24 +966,28 @@ def score(self, X, y=None, sample_weight=None, **params):
         score : float
             Result of calling `score` on the final estimator.
         """
-        Xt = X
-        if not _routing_enabled():
-            for _, name, transform in self._iter(with_final=False):
-                Xt = transform.transform(Xt)
-            score_params = {}
-            if sample_weight is not None:
-                score_params["sample_weight"] = sample_weight
-            return self.steps[-1][1].score(Xt, y, **score_params)
-
-        # metadata routing is enabled.
-        routed_params = process_routing(
-            self, "score", sample_weight=sample_weight, **params
-        )
+        # TODO(1.8): Remove the context manager and use check_is_fitted(self)
+        with _raise_or_warn_if_not_fitted(self):
+            Xt = X
+            if not _routing_enabled():
+                for _, name, transform in self._iter(with_final=False):
+                    Xt = transform.transform(Xt)
+                score_params = {}
+                if sample_weight is not None:
+                    score_params["sample_weight"] = sample_weight
+                return self.steps[-1][1].score(Xt, y, **score_params)
+
+            # metadata routing is enabled.
+            routed_params = process_routing(
+                self, "score", sample_weight=sample_weight, **params
+            )
 
-        Xt = X
-        for _, name, transform in self._iter(with_final=False):
-            Xt = transform.transform(Xt, **routed_params[name].transform)
-        return self.steps[-1][1].score(Xt, y, **routed_params[self.steps[-1][0]].score)
+            Xt = X
+            for _, name, transform in self._iter(with_final=False):
+                Xt = transform.transform(Xt, **routed_params[name].transform)
+            return self.steps[-1][1].score(
+                Xt, y, **routed_params[self.steps[-1][0]].score
+            )
 
     # TODO: once scikit-learn >= 1.4, the following function should be simplified by
     # calling `super().get_metadata_routing()`

imblearn/tests/test_pipeline.py

@@ -49,7 +49,7 @@
 R_TOL = 1e-4
 
 
-class NoFit:
+class NoFit(BaseEstimator):
     """Small class to test parameter dispatching."""
 
     def __init__(self, a=None, b=None):
@@ -109,6 +109,9 @@ def predict(self, X):
     def score(self, X, y=None):
         return np.sum(X)
 
+    def __sklearn_is_fitted__(self):
+        return True
+
 
 class FitParamT(BaseEstimator):
     """Mock classifier"""
@@ -118,6 +121,7 @@ def __init__(self):
 
     def fit(self, X, y, should_succeed=False):
         self.successful = should_succeed
+        self.fitted_ = True
 
     def predict(self, X):
         return self.successful
@@ -146,6 +150,9 @@ def fit(self, X, y):
 class DummyEstimatorParams(BaseEstimator):
     """Mock classifier that takes params on predict"""
 
+    def __sklearn_is_fitted__(self):
+        return True
+
     def fit(self, X, y):
         return self