skfolio 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

skfolio/optimization/convex/_mean_risk.py

@@ -11,6 +11,7 @@ import numpy as np
 import numpy.typing as npt
 import pandas as pd
 import sklearn as sk
+import sklearn.utils.metadata_routing as skm
 
 import skfolio.typing as skt
 from skfolio.measures import RiskMeasure
@@ -681,7 +682,25 @@ class MeanRisk(ConvexOptimization):
                     "`objective_function = ObjectiveFunction.MINIMIZE_RISK`"
                 )
 
-    def fit(self, X: npt.ArrayLike, y: npt.ArrayLike | None = None) -> "MeanRisk":
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = (
+            super()
+            .get_metadata_routing()
+            .add(
+                mu_uncertainty_set_estimator=self.mu_uncertainty_set_estimator,
+                method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+            )
+            .add(
+                covariance_uncertainty_set_estimator=self.covariance_uncertainty_set_estimator,
+                method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+            )
+        )
+        return router
+
+    def fit(
+        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None, **fit_params
+    ) -> "MeanRisk":
         """Fit the Mean-Risk Optimization estimator.
 
         Parameters
@@ -698,6 +717,8 @@ class MeanRisk(ConvexOptimization):
         self : MeanRisk
            Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         self._check_feature_names(X, reset=True)
         # Validate
         self._validation()
@@ -708,7 +729,7 @@ class MeanRisk(ConvexOptimization):
             default=EmpiricalPrior(),
             check_type=BasePrior,
         )
-        self.prior_estimator_.fit(X, y)
+        self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
         prior_model = self.prior_estimator_.prior_model_
         n_observations, n_assets = prior_model.returns.shape
 
@@ -766,7 +787,9 @@ class MeanRisk(ConvexOptimization):
             self.mu_uncertainty_set_estimator_ = sk.clone(
                 self.mu_uncertainty_set_estimator
             )
-            self.mu_uncertainty_set_estimator_.fit(X, y)
+            self.mu_uncertainty_set_estimator_.fit(
+                X, y, **routed_params.mu_uncertainty_set_estimator.fit
+            )
             mu_uncertainty_set = self._cvx_mu_uncertainty_set(
                 mu_uncertainty_set=self.mu_uncertainty_set_estimator_.uncertainty_set_,
                 w=w,
@@ -831,11 +854,11 @@ class MeanRisk(ConvexOptimization):
                 efficient_frontier_size=None,
                 portfolio_params=dict(annualized_factor=1),
             )
-            model.fit(X)
+            model.fit(X, y, **fit_params)
             min_return = model.problem_values_["expected_return"]
             # noinspection PyTypeChecker
             model.set_params(objective_function=ObjectiveFunction.MAXIMIZE_RETURN)
-            model.fit(X)
+            model.fit(X, y, **fit_params)
             max_return = model.problem_values_["expected_return"]
             if max_return <= 0:
                 raise ValueError(
@@ -888,7 +911,11 @@ class MeanRisk(ConvexOptimization):
                         self.covariance_uncertainty_set_estimator_ = sk.clone(
                             self.covariance_uncertainty_set_estimator
                         )
-                        self.covariance_uncertainty_set_estimator_.fit(X, y)
+                        self.covariance_uncertainty_set_estimator_.fit(
+                            X,
+                            y,
+                            **routed_params.covariance_uncertainty_set_estimator.fit,
+                        )
                         args[arg_name] = (
                             self.covariance_uncertainty_set_estimator_.uncertainty_set_
                         )

skfolio/optimization/convex/_risk_budgeting.py

@@ -9,6 +9,7 @@
 import cvxpy as cp
 import numpy as np
 import numpy.typing as npt
+import sklearn.utils.metadata_routing as skm
 
 import skfolio.typing as skt
 from skfolio.measures import RiskMeasure
@@ -440,7 +441,7 @@ class RiskBudgeting(ConvexOptimization):
                 " otherwise the problem becomes non-convex."
             )
 
-    def fit(self, X: npt.ArrayLike, y=None) -> "RiskBudgeting":
+    def fit(self, X: npt.ArrayLike, y=None, **fit_params) -> "RiskBudgeting":
         """Fit the Risk Budgeting Optimization estimator.
 
         Parameters
@@ -458,6 +459,8 @@ class RiskBudgeting(ConvexOptimization):
         self : RiskBudgeting
            Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         self._check_feature_names(X, reset=True)
         # Validate
         self._validation()
@@ -468,7 +471,7 @@ class RiskBudgeting(ConvexOptimization):
             default=EmpiricalPrior(),
             check_type=BasePrior,
         )
-        self.prior_estimator_.fit(X, y)
+        self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
         prior_model = self.prior_estimator_.prior_model_
         n_observations, n_assets = prior_model.returns.shape
 

skfolio/optimization/ensemble/_stacking.py

@@ -12,8 +12,9 @@ from copy import deepcopy
 import numpy as np
 import numpy.typing as npt
 import sklearn as sk
-import sklearn.model_selection as skm
+import sklearn.model_selection as sks
 import sklearn.utils as sku
+import sklearn.utils.metadata_routing as skm
 import sklearn.utils.parallel as skp
 import sklearn.utils.validation as skv
 
@@ -138,7 +139,7 @@ class StackingOptimization(BaseOptimization, BaseComposition):
         self,
         estimators: list[tuple[str, BaseOptimization]],
         final_estimator: BaseOptimization | None = None,
-        cv: skm.BaseCrossValidator | BaseCombinatorialCV | str | int | None = None,
+        cv: sks.BaseCrossValidator | BaseCombinatorialCV | str | int | None = None,
         quantile: float = 0.5,
         quantile_measure: skt.Measure = RatioMeasure.SHARPE_RATIO,
         n_jobs: int | None = None,
@@ -229,8 +230,18 @@ class StackingOptimization(BaseOptimization, BaseComposition):
         """
         return super()._get_params("estimators", deep=deep)
 
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__)
+        for name, estimator in self.estimators:
+            router.add(
+                **{name: estimator},
+                method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+            )
+        return router
+
     def fit(
-        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None
+        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None, **fit_params
     ) -> "StackingOptimization":
         """Fit the Stacking Optimization estimator.
 
@@ -243,11 +254,20 @@ class StackingOptimization(BaseOptimization, BaseComposition):
             Price returns of factors or a target benchmark.
             The default is `None`.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+            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 : StackingOptimization
            Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         names, all_estimators = self._validate_estimators()
         self.final_estimator_ = check_estimator(
             self.final_estimator,
@@ -266,8 +286,10 @@ class StackingOptimization(BaseOptimization, BaseComposition):
             # They are exposed publicly.
             # noinspection PyCallingNonCallable
             self.estimators_ = skp.Parallel(n_jobs=self.n_jobs)(
-                skp.delayed(fit_single_estimator)(sk.clone(est), X, y)
-                for est in all_estimators
+                skp.delayed(fit_single_estimator)(
+                    sk.clone(est), X, y, routed_params[name]["fit"]
+                )
+                for name, est in zip(names, all_estimators, strict=True)
             )
 
         self.named_estimators_ = {
@@ -287,21 +309,22 @@ class StackingOptimization(BaseOptimization, BaseComposition):
                 [estimator.predict(X) for estimator in self.estimators_]
             ).T
         else:
-            cv = skm.check_cv(self.cv)
+            cv = sks.check_cv(self.cv)
             if hasattr(cv, "random_state") and cv.random_state is None:
                 cv.random_state = np.random.RandomState()
             # noinspection PyCallingNonCallable
             cv_predictions = skp.Parallel(n_jobs=self.n_jobs)(
                 skp.delayed(cross_val_predict)(
-                    sk.clone(estimator),
+                    sk.clone(est),
                     X,
                     y,
                     cv=deepcopy(cv),
                     method="predict",
                     n_jobs=self.n_jobs,
+                    params=routed_params[name]["fit"],
                     verbose=self.verbose,
                 )
-                for estimator in all_estimators
+                for name, est in zip(names, all_estimators, strict=True)
             )
 
             # We validate and convert to numpy array only after base-estimator fitting
@@ -326,7 +349,7 @@ class StackingOptimization(BaseOptimization, BaseComposition):
                     )
                     y = y[test_indices]
 
-        fit_single_estimator(self.final_estimator_, X_pred, y)
+        fit_single_estimator(self.final_estimator_, X_pred, y, {})
         outer_weights = self.final_estimator_.weights_
         self.weights_ = outer_weights @ inner_weights
         return self

skfolio/optimization/naive/_naive.py

@@ -5,6 +5,7 @@
 
 import numpy as np
 import numpy.typing as npt
+import sklearn.utils.metadata_routing as skm
 
 from skfolio.optimization._base import BaseOptimization
 from skfolio.prior import BasePrior, EmpiricalPrior
@@ -53,8 +54,16 @@ class InverseVolatility(BaseOptimization):
         super().__init__(portfolio_params=portfolio_params)
         self.prior_estimator = prior_estimator
 
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__).add(
+            prior_estimator=self.prior_estimator,
+            method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+        )
+        return router
+
     def fit(
-        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None
+        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None, **fit_params
     ) -> "InverseVolatility":
         """Fit the Inverse Volatility estimator.
 
@@ -67,18 +76,27 @@ class InverseVolatility(BaseOptimization):
             Price returns of factors or a target benchmark.
             The default is `None`.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+            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 : InverseVolatility
             Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         # fitting prior estimator
         self.prior_estimator_ = check_estimator(
             self.prior_estimator,
             default=EmpiricalPrior(),
             check_type=BasePrior,
         )
-        self.prior_estimator_.fit(X, y)
+        self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
         covariance = self.prior_estimator_.prior_model_.covariance
         w = 1 / np.sqrt(np.diag(covariance))
         self.weights_ = w / sum(w)

skfolio/population/_population.py

@@ -612,6 +612,8 @@ class Population(list):
             title = f"{title} (non-compounded)"
 
         df = pd.concat(cumulative_returns, axis=1).iloc[:, idx]
+        # Sort index because pd.concat unsort NaNs at the end
+        df.sort_index(inplace=True)
         df.columns = deduplicate_names(names)
 
         fig = df.plot(backend="plotly")

skfolio/prior/_base.py

@@ -61,5 +61,5 @@ class BasePrior(skb.BaseEstimator, ABC):
         pass
 
     @abstractmethod
-    def fit(self, X: npt.ArrayLike, y=None):
+    def fit(self, X: npt.ArrayLike, y=None, **fit_params):
         pass

skfolio/prior/_black_litterman.py

@@ -9,6 +9,7 @@
 
 import numpy as np
 import numpy.typing as npt
+import sklearn.utils.metadata_routing as skm
 
 from skfolio.moments import EquilibriumMu
 from skfolio.prior._base import BasePrior, PriorModel
@@ -134,7 +135,15 @@ class BlackLitterman(BasePrior):
         self.view_confidences = view_confidences
         self.risk_free_rate = risk_free_rate
 
-    def fit(self, X: npt.ArrayLike, y=None) -> "BlackLitterman":
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__).add(
+            prior_estimator=self.prior_estimator,
+            method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+        )
+        return router
+
+    def fit(self, X: npt.ArrayLike, y=None, **fit_params) -> "BlackLitterman":
         """Fit the Black & Litterman estimator.
 
         Parameters
@@ -145,18 +154,27 @@ class BlackLitterman(BasePrior):
         y : Ignored
             Not used, present for API consistency by convention.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+            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 : BlackLitterman
             Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         self.prior_estimator_ = check_estimator(
             self.prior_estimator,
             default=EmpiricalPrior(mu_estimator=EquilibriumMu()),
             check_type=BasePrior,
         )
         # fitting prior estimator
-        self.prior_estimator_.fit(X, y)
+        self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
 
         prior_mu = self.prior_estimator_.prior_model_.mu
         prior_covariance = self.prior_estimator_.prior_model_.covariance

skfolio/prior/_empirical.py

@@ -6,6 +6,7 @@
 
 import numpy as np
 import numpy.typing as npt
+import sklearn.utils.metadata_routing as skm
 
 from skfolio.moments import BaseCovariance, BaseMu, EmpiricalCovariance, EmpiricalMu
 from skfolio.prior._base import BasePrior, PriorModel
@@ -86,7 +87,22 @@ class EmpiricalPrior(BasePrior):
         self.is_log_normal = is_log_normal
         self.investment_horizon = investment_horizon
 
-    def fit(self, X: npt.ArrayLike, y=None) -> "EmpiricalPrior":
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = (
+            skm.MetadataRouter(owner=self.__class__.__name__)
+            .add(
+                mu_estimator=self.mu_estimator,
+                method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+            )
+            .add(
+                covariance_estimator=self.covariance_estimator,
+                method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+            )
+        )
+        return router
+
+    def fit(self, X: npt.ArrayLike, y=None, **fit_params) -> "EmpiricalPrior":
         """Fit the Empirical Prior estimator.
 
         Parameters
@@ -97,11 +113,20 @@ class EmpiricalPrior(BasePrior):
         y : Ignored
             Not used, present for API consistency by convention.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+            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 : EmpiricalPrior
             Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         self.mu_estimator_ = check_estimator(
             self.mu_estimator,
             default=EmpiricalMu(),
@@ -120,11 +145,15 @@ class EmpiricalPrior(BasePrior):
                     "`is_log_normal` is `False`"
                 )
             # Expected returns
-            self.mu_estimator_.fit(X, y)
+            # noinspection PyArgumentList
+            self.mu_estimator_.fit(X, y, **routed_params.mu_estimator.fit)
             mu = self.mu_estimator_.mu_
 
             # Covariance
-            self.covariance_estimator_.fit(X, y)
+            # noinspection PyArgumentList
+            self.covariance_estimator_.fit(
+                X, y, **routed_params.covariance_estimator.fit
+            )
             covariance = self.covariance_estimator_.covariance_
         else:
             if self.investment_horizon is None:
@@ -138,11 +167,15 @@ class EmpiricalPrior(BasePrior):
 
             # Estimates the moments on the log returns
             # Expected returns
-            self.mu_estimator_.fit(X_log, y_log)
+            # noinspection PyArgumentList
+            self.mu_estimator_.fit(X_log, y_log, **routed_params.mu_estimator.fit)
             mu = self.mu_estimator_.mu_
 
             # Covariance
-            self.covariance_estimator_.fit(X_log, y_log)
+            # noinspection PyArgumentList
+            self.covariance_estimator_.fit(
+                X_log, y_log, **routed_params.covariance_estimator.fit
+            )
             covariance = self.covariance_estimator_.covariance_
 
             # Using the property of aggregation across time we scale this distribution

skfolio/prior/_factor_model.py

@@ -15,7 +15,8 @@ import numpy as np
 import numpy.typing as npt
 import sklearn.base as skb
 import sklearn.linear_model as skl
-import sklearn.multioutput as skm
+import sklearn.multioutput as skmo
+import sklearn.utils.metadata_routing as skm
 
 from skfolio.prior._base import BasePrior, PriorModel
 from skfolio.prior._empirical import EmpiricalPrior
@@ -74,7 +75,7 @@ class LoadingMatrixRegression(BaseLoadingMatrix):
         Fitted `sklearn.multioutput.MultiOutputRegressor`
     """
 
-    multi_output_regressor_: skm.MultiOutputRegressor
+    multi_output_regressor_: skmo.MultiOutputRegressor
 
     def __init__(
         self,
@@ -84,7 +85,15 @@ class LoadingMatrixRegression(BaseLoadingMatrix):
         self.linear_regressor = linear_regressor
         self.n_jobs = n_jobs
 
-    def fit(self, X: npt.ArrayLike, y: npt.ArrayLike):
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__).add(
+            linear_regressor=self.linear_regressor,
+            method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+        )
+        return router
+
+    def fit(self, X: npt.ArrayLike, y: npt.ArrayLike, **fit_params):
         """Fit the Loading Matrix Regression Estimator.
 
         Parameters
@@ -95,21 +104,30 @@ class LoadingMatrixRegression(BaseLoadingMatrix):
         y : array-like of shape (n_observations, n_factors)
             Price returns of the factors.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+            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 : LoadingMatrixRegression
             Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         _linear_regressor = check_estimator(
             self.linear_regressor,
             default=skl.LassoCV(fit_intercept=False),
             check_type=skb.BaseEstimator,
         )
 
-        self.multi_output_regressor_ = skm.MultiOutputRegressor(
+        self.multi_output_regressor_ = skmo.MultiOutputRegressor(
             _linear_regressor, n_jobs=self.n_jobs
         )
-        self.multi_output_regressor_.fit(X=y, y=X)
+        self.multi_output_regressor_.fit(X=y, y=X, **routed_params.linear_regressor.fit)
         # noinspection PyUnresolvedReferences
         n_assets = X.shape[1]
         self.loading_matrix_ = np.array(
@@ -196,8 +214,16 @@ class FactorModel(BasePrior):
         self.higham = higham
         self.max_iteration = max_iteration
 
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__).add(
+            factor_prior_estimator=self.factor_prior_estimator,
+            method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+        )
+        return router
+
     # noinspection PyMethodOverriding, PyPep8Naming
-    def fit(self, X: npt.ArrayLike, y: Any):
+    def fit(self, X: npt.ArrayLike, y: Any, **fit_params):
         """Fit the Factor Model estimator.
 
         Parameters
@@ -208,11 +234,20 @@ class FactorModel(BasePrior):
         y : array-like of shape (n_observations, n_factors)
             Factors' returns.
 
+        **fit_params : dict
+            Parameters to pass to the underlying estimators.
+            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 : FactorModel
             Fitted estimator.
         """
+        routed_params = skm.process_routing(self, "fit", **fit_params)
+
         self.factor_prior_estimator_ = check_estimator(
             self.factor_prior_estimator,
             default=EmpiricalPrior(),
@@ -225,7 +260,9 @@ class FactorModel(BasePrior):
         )
 
         # Fitting prior estimator
-        self.factor_prior_estimator_.fit(y)
+        self.factor_prior_estimator_.fit(
+            X=y, **routed_params.factor_prior_estimator.fit
+        )
         factor_mu = self.factor_prior_estimator_.prior_model_.mu
         factor_covariance = self.factor_prior_estimator_.prior_model_.covariance
 

skfolio/uncertainty_set/_base.py

@@ -10,6 +10,9 @@ from dataclasses import dataclass
 import numpy as np
 import numpy.typing as npt
 import sklearn.base as skb
+import sklearn.utils.metadata_routing as skm
+
+from skfolio.prior import BasePrior
 
 
 # frozen=True with eq=False will lead to an id-based hashing which is needed for
@@ -54,13 +57,22 @@ class BaseMuUncertaintySet(skb.BaseEstimator, ABC):
     """
 
     uncertainty_set_: UncertaintySet
+    prior_estimator_: BasePrior
 
     @abstractmethod
-    def __init__(self):
-        pass
+    def __init__(self, prior_estimator: BasePrior | None = None):
+        self.prior_estimator = prior_estimator
+
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__).add(
+            prior_estimator=self.prior_estimator,
+            method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+        )
+        return router
 
     @abstractmethod
-    def fit(self, X: npt.ArrayLike, y=None):
+    def fit(self, X: npt.ArrayLike, y=None, **fit_params):
         pass
 
 
@@ -75,14 +87,11 @@ class BaseCovarianceUncertaintySet(skb.BaseEstimator, ABC):
     """
 
     uncertainty_set_: UncertaintySet
+    prior_estimator_: BasePrior
 
     @abstractmethod
-    def __init__(self):
-        pass
-
-    @abstractmethod
-    def fit(self, X: npt.ArrayLike, y=None):
-        pass
+    def __init__(self, prior_estimator: BasePrior | None = None):
+        self.prior_estimator = prior_estimator
 
     def _validate_X_y(self, X: npt.ArrayLike, y: npt.ArrayLike | None = None):
         """Validate X and y if provided.
@@ -108,3 +117,15 @@ class BaseCovarianceUncertaintySet(skb.BaseEstimator, ABC):
         else:
             X, y = self._validate_data(X, y, multi_output=True)
         return X, y
+
+    def get_metadata_routing(self):
+        # noinspection PyTypeChecker
+        router = skm.MetadataRouter(owner=self.__class__.__name__).add(
+            prior_estimator=self.prior_estimator,
+            method_mapping=skm.MethodMapping().add(caller="fit", callee="fit"),
+        )
+        return router
+
+    @abstractmethod
+    def fit(self, X: npt.ArrayLike, y=None, **fit_params):
+        pass