iter

Author: glemaitre

imblearn/base.py

@@ -12,30 +12,11 @@
 from sklearn.utils.multiclass import check_classification_targets
 
 from .utils import check_sampling_strategy, check_target_type
-from .utils._param_validation import validate_parameter_constraints
+from .utils._sklearn_compat import _fit_context, validate_data
 from .utils._validation import ArraysTransformer
 
 
-class _ParamsValidationMixin:
-    """Mixin class to validate parameters."""
-
-    def _validate_params(self):
-        """Validate types and values of constructor parameters.
-
-        The expected type and values must be defined in the `_parameter_constraints`
-        class attribute, which is a dictionary `param_name: list of constraints`. See
-        the docstring of `validate_parameter_constraints` for a description of the
-        accepted constraints.
-        """
-        if hasattr(self, "_parameter_constraints"):
-            validate_parameter_constraints(
-                self._parameter_constraints,
-                self.get_params(deep=False),
-                caller_name=self.__class__.__name__,
-            )
-
-
-class SamplerMixin(_ParamsValidationMixin, BaseEstimator, metaclass=ABCMeta):
+class SamplerMixin(metaclass=ABCMeta):
     """Mixin class for samplers with abstract method.
 
     Warning: This class should not be used directly. Use the derive classes
@@ -44,6 +25,7 @@ class SamplerMixin(_ParamsValidationMixin, BaseEstimator, metaclass=ABCMeta):
 
     _estimator_type = "sampler"
 
+    @_fit_context(prefer_skip_nested_validation=True)
     def fit(self, X, y):
         """Check inputs and statistics of the sampler.
 
@@ -133,7 +115,7 @@ def _fit_resample(self, X, y):
         pass
 
 
-class BaseSampler(SamplerMixin, OneToOneFeatureMixin):
+class BaseSampler(SamplerMixin, OneToOneFeatureMixin, BaseEstimator):
     """Base class for sampling algorithms.
 
     Warning: This class should not be used directly. Use the derive classes
@@ -147,7 +129,7 @@ def _check_X_y(self, X, y, accept_sparse=None):
         if accept_sparse is None:
             accept_sparse = ["csr", "csc"]
         y, binarize_y = check_target_type(y, indicate_one_vs_all=True)
-        X, y = self._validate_data(X, y, reset=True, accept_sparse=accept_sparse)
+        X, y = validate_data(self, X=X, y=y, reset=True, accept_sparse=accept_sparse)
         return X, y, binarize_y
 
     def fit(self, X, y):
@@ -199,6 +181,24 @@ def fit_resample(self, X, y):
     def _more_tags(self):
         return {"X_types": ["2darray", "sparse", "dataframe"]}
 
+    def __sklearn_tags__(self):
+        from .utils._sklearn_compat import TargetTags
+        from .utils._tags import Tags, SamplerTags, InputTags
+
+        tags = Tags(
+            estimator_type="sampler",
+            target_tags=TargetTags(required=True),
+            transformer_tags=None,
+            regressor_tags=None,
+            classifier_tags=None,
+            sampler_tags=SamplerTags(),
+        )
+        tags.input_tags = InputTags()
+        tags.input_tags.two_d_array = True
+        tags.input_tags.sparse = True
+        tags.input_tags.dataframe = True
+        return tags
+
 
 def _identity(X, y):
     return X, y

imblearn/datasets/_imbalance.py

@@ -10,7 +10,7 @@
 
 from ..under_sampling import RandomUnderSampler
 from ..utils import check_sampling_strategy
-from ..utils._param_validation import validate_params
+from ..utils._sklearn_compat import validate_params
 
 
 @validate_params(

imblearn/datasets/_zenodo.py

@@ -55,7 +55,7 @@
 from sklearn.datasets import get_data_home
 from sklearn.utils import Bunch, check_random_state
 
-from ..utils._param_validation import validate_params
+from ..utils._sklearn_compat import validate_params
 
 URL = "https://zenodo.org/record/61452/files/benchmark-imbalanced-learn.tar.gz"
 PRE_FILENAME = "x"

imblearn/ensemble/_bagging.py

@@ -18,15 +18,14 @@
 from sklearn.utils.metaestimators import available_if
 from sklearn.utils.parallel import Parallel, delayed
 from sklearn.utils.validation import check_is_fitted
+from sklearn.utils._param_validation import HasMethods, Interval, StrOptions
 
-from ..base import _ParamsValidationMixin
 from ..pipeline import Pipeline
 from ..under_sampling import RandomUnderSampler
 from ..under_sampling.base import BaseUnderSampler
 from ..utils import Substitution, check_sampling_strategy, check_target_type
 from ..utils._docstring import _n_jobs_docstring, _random_state_docstring
-from ..utils._param_validation import HasMethods, Interval, StrOptions
-from ..utils.fixes import _fit_context
+from ..utils._sklearn_compat import _fit_context, validate_data
 from ._common import _bagging_parameter_constraints, _estimator_has
 
 sklearn_version = parse_version(sklearn.__version__)
@@ -37,7 +36,7 @@
     n_jobs=_n_jobs_docstring,
     random_state=_random_state_docstring,
 )
-class BalancedBaggingClassifier(_ParamsValidationMixin, BaggingClassifier):
+class BalancedBaggingClassifier(BaggingClassifier):
     """A Bagging classifier with additional balancing.
 
     This implementation of Bagging is similar to the scikit-learn
@@ -382,11 +381,12 @@ def decision_function(self, X):
         check_is_fitted(self)
 
         # Check data
-        X = self._validate_data(
-            X,
+        X = validate_data(
+            self,
+            X=X,
             accept_sparse=["csr", "csc"],
             dtype=None,
-            force_all_finite=False,
+            ensure_all_finite=False,
             reset=False,
         )
 
@@ -425,3 +425,7 @@ def _more_tags(self):
         else:
             tags[tags_key] = {failing_test: reason}
         return tags
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        return tags

imblearn/ensemble/_common.py

@@ -2,7 +2,7 @@
 
 from sklearn.tree._criterion import Criterion
 
-from ..utils._param_validation import (
+from sklearn.utils._param_validation import (
     HasMethods,
     Hidden,
     Interval,

imblearn/ensemble/_easy_ensemble.py

@@ -19,15 +19,14 @@
 from sklearn.utils.metaestimators import available_if
 from sklearn.utils.parallel import Parallel, delayed
 from sklearn.utils.validation import check_is_fitted
+from sklearn.utils._param_validation import Interval, StrOptions
 
-from ..base import _ParamsValidationMixin
 from ..pipeline import Pipeline
 from ..under_sampling import RandomUnderSampler
 from ..under_sampling.base import BaseUnderSampler
 from ..utils import Substitution, check_sampling_strategy, check_target_type
 from ..utils._docstring import _n_jobs_docstring, _random_state_docstring
-from ..utils._param_validation import Interval, StrOptions
-from ..utils.fixes import _fit_context
+from ..utils._sklearn_compat import _fit_context, get_tags, validate_data
 from ._common import _bagging_parameter_constraints, _estimator_has
 
 MAX_INT = np.iinfo(np.int32).max
@@ -39,7 +38,7 @@
     n_jobs=_n_jobs_docstring,
     random_state=_random_state_docstring,
 )
-class EasyEnsembleClassifier(_ParamsValidationMixin, BaggingClassifier):
+class EasyEnsembleClassifier(BaggingClassifier):
     """Bag of balanced boosted learners also known as EasyEnsemble.
 
     This algorithm is known as EasyEnsemble [1]_. The classifier is an
@@ -311,11 +310,12 @@ def decision_function(self, X):
         check_is_fitted(self)
 
         # Check data
-        X = self._validate_data(
-            X,
+        X = validate_data(
+            self,
+            X=X,
             accept_sparse=["csr", "csc"],
             dtype=None,
-            force_all_finite=False,
+            ensure_all_finite=False,
             reset=False,
         )
 
@@ -346,9 +346,17 @@ def base_estimator_(self):
 
     def _get_estimator(self):
         if self.estimator is None:
-            return AdaBoostClassifier(algorithm="SAMME")
+            if parse_version("1.4") <= sklearn_version < parse_version("1.6"):
+                return AdaBoostClassifier(algorithm="SAMME")
+            else:
+                return AdaBoostClassifier()
         return self.estimator
 
     # TODO: remove when minimum supported version of scikit-learn is 1.5
     def _more_tags(self):
         return {"allow_nan": _safe_tags(self._get_estimator(), "allow_nan")}
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.input_tags.allow_nan = get_tags(self._get_estimator()).input_tags.allow_nan
+        return tags

imblearn/ensemble/_forest.py

@@ -27,19 +27,18 @@
 from sklearn.utils.multiclass import type_of_target
 from sklearn.utils.parallel import Parallel, delayed
 from sklearn.utils.validation import _check_sample_weight
+from sklearn.utils._param_validation import Hidden, Interval, StrOptions
 
-from ..base import _ParamsValidationMixin
 from ..pipeline import make_pipeline
 from ..under_sampling import RandomUnderSampler
 from ..utils import Substitution
 from ..utils._docstring import _n_jobs_docstring, _random_state_docstring
-from ..utils._param_validation import Hidden, Interval, StrOptions
+from ..utils._sklearn_compat import _fit_context, validate_data
 from ..utils._validation import check_sampling_strategy
-from ..utils.fixes import _fit_context
 from ._common import _random_forest_classifier_parameter_constraints
 
 MAX_INT = np.iinfo(np.int32).max
-sklearn_version = parse_version(sklearn.__version__)
+sklearn_version = parse_version(parse_version(sklearn.__version__).base_version)
 
 
 def _local_parallel_build_trees(
@@ -77,7 +76,7 @@ def _local_parallel_build_trees(
         "bootstrap": bootstrap,
     }
 
-    if parse_version(sklearn_version.base_version) >= parse_version("1.4"):
+    if sklearn_version >= parse_version("1.4"):
         # TODO: remove when the minimum supported version of scikit-learn will be 1.4
         # support for missing values
         params_parallel_build_trees["missing_values_in_feature_mask"] = (
@@ -93,7 +92,7 @@ def _local_parallel_build_trees(
     n_jobs=_n_jobs_docstring,
     random_state=_random_state_docstring,
 )
-class BalancedRandomForestClassifier(_ParamsValidationMixin, RandomForestClassifier):
+class BalancedRandomForestClassifier(RandomForestClassifier):
     """A balanced random forest classifier.
 
     A balanced random forest differs from a classical random forest by the
@@ -474,7 +473,7 @@ def __init__(
             "max_samples": max_samples,
         }
         # TODO: remove when the minimum supported version of scikit-learn will be 1.4
-        if parse_version(sklearn_version.base_version) >= parse_version("1.4"):
+        if sklearn_version >= parse_version("1.4"):
             # use scikit-learn support for monotonic constraints
             params_random_forest["monotonic_cst"] = monotonic_cst
         else:
@@ -596,22 +595,23 @@ def fit(self, X, y, sample_weight=None):
 
         # TODO: remove when the minimum supported version of scipy will be 1.4
         # Support for missing values
-        if parse_version(sklearn_version.base_version) >= parse_version("1.4"):
-            force_all_finite = False
+        if sklearn_version >= parse_version("1.4"):
+            ensure_all_finite = False
         else:
-            force_all_finite = True
+            ensure_all_finite = True
 
-        X, y = self._validate_data(
-            X,
-            y,
+        X, y = validate_data(
+            self,
+            X=X,
+            y=y,
             multi_output=True,
             accept_sparse="csc",
             dtype=DTYPE,
-            force_all_finite=force_all_finite,
+            ensure_all_finite=ensure_all_finite,
         )
 
         # TODO: remove when the minimum supported version of scikit-learn will be 1.4
-        if parse_version(sklearn_version.base_version) >= parse_version("1.4"):
+        if sklearn_version >= parse_version("1.4"):
             # _compute_missing_values_in_feature_mask checks if X has missing values and
             # will raise an error if the underlying tree base estimator can't handle
             # missing values. Only the criterion is required to determine if the tree
@@ -882,3 +882,10 @@ def _compute_oob_predictions(self, X, y):
 
     def _more_tags(self):
         return {"multioutput": False, "multilabel": False}
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.target_tags.multi_output = False
+        tags.classifier_tags.multi_label = False
+        tags.input_tags.allow_nan = sklearn_version >= parse_version("1.4")
+        return tags

imblearn/ensemble/_weight_boosting.py

@@ -1,5 +1,6 @@
 import copy
 import numbers
+import warnings
 from copy import deepcopy
 
 import numpy as np
@@ -11,15 +12,14 @@
 from sklearn.utils import _safe_indexing
 from sklearn.utils.fixes import parse_version
 from sklearn.utils.validation import has_fit_parameter
+from sklearn.utils._param_validation import Hidden, Interval, StrOptions
 
-from ..base import _ParamsValidationMixin
 from ..pipeline import make_pipeline
 from ..under_sampling import RandomUnderSampler
 from ..under_sampling.base import BaseUnderSampler
 from ..utils import Substitution, check_target_type
 from ..utils._docstring import _random_state_docstring
-from ..utils._param_validation import Interval, StrOptions
-from ..utils.fixes import _fit_context
+from ..utils._sklearn_compat import _fit_context
 from ._common import _adaboost_classifier_parameter_constraints
 
 sklearn_version = parse_version(sklearn.__version__)
@@ -29,7 +29,7 @@
     sampling_strategy=BaseUnderSampler._sampling_strategy_docstring,
     random_state=_random_state_docstring,
 )
-class RUSBoostClassifier(_ParamsValidationMixin, AdaBoostClassifier):
+class RUSBoostClassifier(AdaBoostClassifier):
     """Random under-sampling integrated in the learning of AdaBoost.
 
     During learning, the problem of class balancing is alleviated by random
@@ -167,6 +167,10 @@ class RUSBoostClassifier(_ParamsValidationMixin, AdaBoostClassifier):
 
     _parameter_constraints.update(
         {
+            "algorithm": [
+                StrOptions({"SAMME", "SAMME.R"}),
+                Hidden(StrOptions({"deprecated"})),
+            ],
             "sampling_strategy": [
                 Interval(numbers.Real, 0, 1, closed="right"),
                 StrOptions({"auto", "majority", "not minority", "not majority", "all"}),
@@ -186,17 +190,17 @@ def __init__(
         *,
         n_estimators=50,
         learning_rate=1.0,
-        algorithm="SAMME.R",
+        algorithm="deprecated",
         sampling_strategy="auto",
         replacement=False,
         random_state=None,
     ):
         super().__init__(
             n_estimators=n_estimators,
             learning_rate=learning_rate,
-            algorithm=algorithm,
             random_state=random_state,
         )
+        self.algorithm = algorithm
         self.estimator = estimator
         self.sampling_strategy = sampling_strategy
         self.replacement = replacement
@@ -394,3 +398,16 @@ def _boost_discrete(self, iboost, X, y, sample_weight, random_state):
             sample_weight *= np.exp(estimator_weight * incorrect * (sample_weight > 0))
 
         return sample_weight, estimator_weight, estimator_error
+
+    def _boost(self, iboost, X, y, sample_weight, random_state):
+        if self.algorithm != "deprecated":
+            warnings.warn(
+                "`algorithm` parameter is deprecated in 0.12 and will be removed in "
+                "0.14. In the future, the SAMME algorithm will always be used.",
+                FutureWarning,
+            )
+        if self.algorithm == "SAMME.R":
+            return self._boost_real(iboost, X, y, sample_weight, random_state)
+
+        else:  # elif self.algorithm == "SAMME":
+            return self._boost_discrete(iboost, X, y, sample_weight, random_state)