scikit-learn · glemaitre · Feb 22, 2024 · Oct 14, 2023 · Oct 19, 2023 · Oct 23, 2023
diff --git a/doc/metadata_routing.rst b/doc/metadata_routing.rst
@@ -274,6 +274,8 @@ Meta-estimators and functions supporting metadata routing:
 
 - :class:`sklearn.calibration.CalibratedClassifierCV`
 - :class:`sklearn.compose.ColumnTransformer`
+- :class:`sklearn.ensemble.VotingClassifier`
+- :class:`sklearn.ensemble.VotingRegressor`
 - :class:`sklearn.ensemble.BaggingClassifier`
 - :class:`sklearn.ensemble.BaggingRegressor`
 - :class:`sklearn.feature_selection.SelectFromModel`
@@ -310,8 +312,6 @@ Meta-estimators and tools not supporting metadata routing yet:
 - :class:`sklearn.ensemble.AdaBoostRegressor`
 - :class:`sklearn.ensemble.StackingClassifier`
 - :class:`sklearn.ensemble.StackingRegressor`
-- :class:`sklearn.ensemble.VotingClassifier`
-- :class:`sklearn.ensemble.VotingRegressor`
 - :class:`sklearn.feature_selection.RFE`
 - :class:`sklearn.feature_selection.RFECV`
 - :class:`sklearn.feature_selection.SequentialFeatureSelector`

diff --git a/doc/whats_new/v1.5.rst b/doc/whats_new/v1.5.rst
@@ -48,6 +48,11 @@ more details.
   via their `fit` methods.
   :pr:`28432` by :user:`Adam Li <adam2392>` and :user:`Benjamin Bossan <BenjaminBossan>`.
 
+- |Feature| :class:`ensemble.VotingClassifier` and
+  :class:`ensemble.VotingRegressor` now support metadata routing and pass
+  ``**fit_params`` to the underlying estimators via their `fit` methods.
+  :pr:`27584` by :user:`Stefanie Senger <StefanieSenger>`.
+
 Changelog
 ---------
 

diff --git a/sklearn/compose/tests/test_column_transformer.py b/sklearn/compose/tests/test_column_transformer.py
@@ -2517,7 +2517,6 @@ def transform(self, X, sample_weight=None, metadata=None):
 
     X = np.array([[0, 1, 2], [2, 4, 6]]).T
     y = [1, 2, 3]
-    _Registry()
     sample_weight, metadata = [1], "a"
     trs = ColumnTransformer(
         [

diff --git a/sklearn/ensemble/_base.py b/sklearn/ensemble/_base.py
@@ -12,17 +12,20 @@
 from ..base import BaseEstimator, MetaEstimatorMixin, clone, is_classifier, is_regressor
 from ..utils import Bunch, _print_elapsed_time, check_random_state
 from ..utils._tags import _safe_tags
+from ..utils.metadata_routing import _routing_enabled
 from ..utils.metaestimators import _BaseComposition
 
 
 def _fit_single_estimator(
-    estimator, X, y, sample_weight=None, message_clsname=None, message=None
+    estimator, X, y, fit_params, message_clsname=None, message=None
 ):
     """Private function used to fit an estimator within a job."""
-    if sample_weight is not None:
+    # TODO(SLEP6): remove if condition for unrouted sample_weight when metadata
+    # routing can't be disabled.
+    if not _routing_enabled() and "sample_weight" in fit_params:
         try:
             with _print_elapsed_time(message_clsname, message):
-                estimator.fit(X, y, sample_weight=sample_weight)
+                estimator.fit(X, y, sample_weight=fit_params["sample_weight"])
         except TypeError as exc:
             if "unexpected keyword argument 'sample_weight'" in str(exc):
                 raise TypeError(
@@ -33,7 +36,7 @@ def _fit_single_estimator(
             raise
     else:
         with _print_elapsed_time(message_clsname, message):
-            estimator.fit(X, y)
+            estimator.fit(X, y, **fit_params)
     return estimator
 
 

diff --git a/sklearn/ensemble/_stacking.py b/sklearn/ensemble/_stacking.py
@@ -201,6 +201,14 @@ def fit(self, X, y, sample_weight=None):
         names, all_estimators = self._validate_estimators()
         self._validate_final_estimator()
 
+        # FIXME: when adding support for metadata routing in Stacking*.
+        # This is a hotfix to make StackingClassifier and StackingRegressor
+        # pass the tests despite not supporting metadata routing but sharing
+        # the same base class with VotingClassifier and VotingRegressor.
+        fit_params = dict()
+        if sample_weight is not None:
+            fit_params["sample_weight"] = sample_weight
+
         stack_method = [self.stack_method] * len(all_estimators)
 
         if self.cv == "prefit":
@@ -214,7 +222,7 @@ def fit(self, X, y, sample_weight=None):
             # base estimators will be used in transform, predict, and
             # predict_proba. They are exposed publicly.
             self.estimators_ = Parallel(n_jobs=self.n_jobs)(
-                delayed(_fit_single_estimator)(clone(est), X, y, sample_weight)
+                delayed(_fit_single_estimator)(clone(est), X, y, fit_params)
                 for est in all_estimators
                 if est != "drop"
             )
@@ -253,9 +261,6 @@ def fit(self, X, y, sample_weight=None):
             if hasattr(cv, "random_state") and cv.random_state is None:
                 cv.random_state = np.random.RandomState()
 
-            fit_params = (
-                {"sample_weight": sample_weight} if sample_weight is not None else None
-            )
             predictions = Parallel(n_jobs=self.n_jobs)(
                 delayed(cross_val_predict)(
                     clone(est),
@@ -280,9 +285,7 @@ def fit(self, X, y, sample_weight=None):
         ]
 
         X_meta = self._concatenate_predictions(X, predictions)
-        _fit_single_estimator(
-            self.final_estimator_, X_meta, y, sample_weight=sample_weight
-        )
+        _fit_single_estimator(self.final_estimator_, X_meta, y, fit_params=fit_params)
 
         return self
 

diff --git a/sklearn/ensemble/_voting.py b/sklearn/ensemble/_voting.py
@@ -31,14 +31,18 @@
 from ..utils._estimator_html_repr import _VisualBlock
 from ..utils._param_validation import StrOptions
 from ..utils.metadata_routing import (
-    _raise_for_unsupported_routing,
-    _RoutingNotSupportedMixin,
+    MetadataRouter,
+    MethodMapping,
+    _raise_for_params,
+    _routing_enabled,
+    process_routing,
 )
 from ..utils.metaestimators import available_if
 from ..utils.multiclass import type_of_target
 from ..utils.parallel import Parallel, delayed
 from ..utils.validation import (
     _check_feature_names_in,
+    _deprecate_positional_args,
     check_is_fitted,
     column_or_1d,
 )
@@ -76,7 +80,7 @@ def _predict(self, X):
         return np.asarray([est.predict(X) for est in self.estimators_]).T
 
     @abstractmethod
-    def fit(self, X, y, sample_weight=None):
+    def fit(self, X, y, **fit_params):
         """Get common fit operations."""
         names, clfs = self._validate_estimators()
 
@@ -86,16 +90,27 @@ def fit(self, X, y, sample_weight=None):
                 f" {len(self.weights)} weights, {len(self.estimators)} estimators"
             )
 
+        if _routing_enabled():
+            routed_params = process_routing(self, "fit", **fit_params)
+        else:
+            routed_params = Bunch()
+            for name in names:
+                routed_params[name] = Bunch(fit={})
+                if "sample_weight" in fit_params:
+                    routed_params[name].fit["sample_weight"] = fit_params[
+                        "sample_weight"
+                    ]
+
         self.estimators_ = Parallel(n_jobs=self.n_jobs)(
             delayed(_fit_single_estimator)(
                 clone(clf),
                 X,
                 y,
-                sample_weight=sample_weight,
+                fit_params=routed_params[name]["fit"],
                 message_clsname="Voting",
-                message=self._log_message(names[idx], idx + 1, len(clfs)),
+                message=self._log_message(name, idx + 1, len(clfs)),
             )
-            for idx, clf in enumerate(clfs)
+            for idx, (name, clf) in enumerate(zip(names, clfs))
             if clf != "drop"
         )
 
@@ -156,8 +171,32 @@ def _sk_visual_block_(self):
         names, estimators = zip(*self.estimators)
         return _VisualBlock("parallel", estimators, names=names)
 
+    def get_metadata_routing(self):
+        """Get metadata routing of this object.
+
+        Please check :ref:`User Guide <metadata_routing>` on how the routing
+        mechanism works.
+
+        .. versionadded:: 1.5
+
+        Returns
+        -------
+        routing : MetadataRouter
+            A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating
+            routing information.
+        """
+        router = MetadataRouter(owner=self.__class__.__name__)
+
+        # `self.estimators` is a list of (name, est) tuples
+        for name, estimator in self.estimators:
+            router.add(
+                **{name: estimator},
+                method_mapping=MethodMapping().add(callee="fit", caller="fit"),
+            )
+        return router
+
 
-class VotingClassifier(_RoutingNotSupportedMixin, ClassifierMixin, _BaseVoting):
+class VotingClassifier(ClassifierMixin, _BaseVoting):
     """Soft Voting/Majority Rule classifier for unfitted estimators.
 
     Read more in the :ref:`User Guide <voting_classifier>`.
@@ -317,7 +356,11 @@ def __init__(
         # estimators in VotingClassifier.estimators are not validated yet
         prefer_skip_nested_validation=False
     )
-    def fit(self, X, y, sample_weight=None):
+    # TODO(1.7): remove `sample_weight` from the signature after deprecation
+    # cycle; pop it from `fit_params` before the `_raise_for_params` check and
+    # reinsert later, for backwards compatibility
+    @_deprecate_positional_args(version="1.7")
+    def fit(self, X, y, *, sample_weight=None, **fit_params):
         """Fit the estimators.
 
         Parameters
@@ -336,12 +379,23 @@ def fit(self, X, y, sample_weight=None):
 
             .. versionadded:: 0.18
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+
+            .. versionadded:: 1.5
+
+                Only available if `enable_metadata_routing=True`,
+                which can be set by using
+                ``sklearn.set_config(enable_metadata_routing=True)``.
+                See :ref:`Metadata Routing User Guide <metadata_routing>` for
+                more details.
+
         Returns
         -------
         self : object
             Returns the instance itself.
         """
-        _raise_for_unsupported_routing(self, "fit", sample_weight=sample_weight)
+        _raise_for_params(fit_params, self, "fit")
         y_type = type_of_target(y, input_name="y")
         if y_type in ("unknown", "continuous"):
             # raise a specific ValueError for non-classification tasks
@@ -363,7 +417,10 @@ def fit(self, X, y, sample_weight=None):
         self.classes_ = self.le_.classes_
         transformed_y = self.le_.transform(y)
 
-        return super().fit(X, transformed_y, sample_weight)
+        if sample_weight is not None:
+            fit_params["sample_weight"] = sample_weight
+
+        return super().fit(X, transformed_y, **fit_params)
 
     def predict(self, X):
         """Predict class labels for X.
@@ -495,7 +552,7 @@ def get_feature_names_out(self, input_features=None):
         return np.asarray(names_out, dtype=object)
 
 
-class VotingRegressor(_RoutingNotSupportedMixin, RegressorMixin, _BaseVoting):
+class VotingRegressor(RegressorMixin, _BaseVoting):
     """Prediction voting regressor for unfitted estimators.
 
     A voting regressor is an ensemble meta-estimator that fits several base
@@ -596,7 +653,11 @@ def __init__(self, estimators, *, weights=None, n_jobs=None, verbose=False):
         # estimators in VotingRegressor.estimators are not validated yet
         prefer_skip_nested_validation=False
     )
-    def fit(self, X, y, sample_weight=None):
+    # TODO(1.7): remove `sample_weight` from the signature after deprecation cycle;
+    # pop it from `fit_params` before the `_raise_for_params` check and reinsert later,
+    # for backwards compatibility
+    @_deprecate_positional_args(version="1.7")
+    def fit(self, X, y, *, sample_weight=None, **fit_params):
         """Fit the estimators.
 
         Parameters
@@ -613,14 +674,27 @@ def fit(self, X, y, sample_weight=None):
             Note that this is supported only if all underlying estimators
             support sample weights.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+
+            .. versionadded:: 1.5
+
+                Only available if `enable_metadata_routing=True`,
+                which can be set by using
+                ``sklearn.set_config(enable_metadata_routing=True)``.
+                See :ref:`Metadata Routing User Guide <metadata_routing>` for
+                more details.
+
         Returns
         -------
         self : object
             Fitted estimator.
         """
-        _raise_for_unsupported_routing(self, "fit", sample_weight=sample_weight)
+        _raise_for_params(fit_params, self, "fit")
         y = column_or_1d(y, warn=True)
-        return super().fit(X, y, sample_weight)
+        if sample_weight is not None:
+            fit_params["sample_weight"] = sample_weight
+        return super().fit(X, y, **fit_params)
 
     def predict(self, X):
         """Predict regression target for X.