skfolio 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

skfolio/optimization/_base.py

@@ -7,12 +7,14 @@ from abc import ABC, abstractmethod
 
 import numpy as np
 import numpy.typing as npt
+import pandas as pd
 import sklearn.base as skb
 from sklearn.utils.validation import check_is_fitted
 
 from skfolio.measures import RatioMeasure
 from skfolio.population import Population
 from skfolio.portfolio import Portfolio
+from skfolio.prior import ReturnDistribution
 
 # Copyright (c) 2023
 # Author: Hugo Delatte <delatte.hugo@gmail.com>
@@ -45,6 +47,8 @@ class BaseOptimization(skb.BaseEstimator, ABC):
     """
 
     weights_: np.ndarray
+    n_features_in_: int
+    feature_names_in_: np.ndarray
 
     @abstractmethod
     def __init__(self, portfolio_params: dict | None = None):
@@ -54,7 +58,7 @@ class BaseOptimization(skb.BaseEstimator, ABC):
     def fit(self, X: npt.ArrayLike, y: npt.ArrayLike | None = None):
         pass
 
-    def predict(self, X: npt.ArrayLike) -> Portfolio | Population:
+    def predict(self, X: npt.ArrayLike | ReturnDistribution) -> Portfolio | Population:
         """Predict the `Portfolio` or `Population` of `Portfolio` on `X` based on the
         fitted weights.
 
@@ -83,6 +87,18 @@ class BaseOptimization(skb.BaseEstimator, ABC):
         else:
             ptf_kwargs = self.portfolio_params.copy()
 
+        # Set X and sample_weight
+        if isinstance(X, ReturnDistribution):
+            ptf_kwargs["sample_weight"] = X.sample_weight
+            if hasattr(self, "feature_names_in_"):
+                ptf_kwargs["X"] = pd.DataFrame(
+                    X.returns, columns=self.feature_names_in_
+                )
+            else:
+                ptf_kwargs["X"] = X.returns
+        else:
+            ptf_kwargs["X"] = X
+
         # Set the default portfolio parameters equal to the optimization parameters
         for param in [
             "transaction_costs",
@@ -105,7 +121,6 @@ class BaseOptimization(skb.BaseEstimator, ABC):
             return Population(
                 [
                     Portfolio(
-                        X=X,
                         weights=self.weights_[i],
                         name=f"ptf{i} - {name}",
                         **ptf_kwargs,
@@ -113,9 +128,11 @@ class BaseOptimization(skb.BaseEstimator, ABC):
                     for i in range(n_portfolios)
                 ]
             )
-        return Portfolio(X=X, weights=self.weights_, name=name, **ptf_kwargs)
+        return Portfolio(weights=self.weights_, name=name, **ptf_kwargs)
 
-    def score(self, X: npt.ArrayLike, y: npt.ArrayLike = None) -> float:
+    def score(
+        self, X: npt.ArrayLike | ReturnDistribution, y: npt.ArrayLike = None
+    ) -> float:
         """Prediction score.
         If the prediction is a single `Portfolio`, the score is the Sharpe Ratio.
         If the prediction is a `Population` of `Portfolio`, the score is the mean of all

skfolio/optimization/cluster/hierarchical/_base.py

@@ -20,7 +20,7 @@ from skfolio.distance import BaseDistance
 from skfolio.measures import ExtraRiskMeasure, RiskMeasure
 from skfolio.optimization._base import BaseOptimization
 from skfolio.portfolio import Portfolio
-from skfolio.prior import BasePrior, PriorModel
+from skfolio.prior import BasePrior, ReturnDistribution
 from skfolio.utils.tools import input_to_array
 
 
@@ -57,7 +57,7 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
 
     prior_estimator : BasePrior, optional
         :ref:`Prior estimator <prior>`.
-        The prior estimator is used to estimate the :class:`~skfolio.prior.PriorModel`
+        The prior estimator is used to estimate the :class:`~skfolio.prior.ReturnDistribution`
         containing the estimation of assets expected returns, covariance matrix and
         returns. The moments and returns estimations are used for the risk computation
         and the returns estimation are used by the distance matrix estimator.
@@ -135,7 +135,7 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
             needs to be homogenous to the periodicity of :math:`\mu`. For example, if
             the input `X` is composed of **daily** returns, the `transaction_costs` need
             to be expressed as **daily** costs.
-            (See :ref:`sphx_glr_auto_examples_1_mean_risk_plot_6_transaction_costs.py`)
+            (See :ref:`sphx_glr_auto_examples_mean_risk_plot_6_transaction_costs.py`)
 
     management_fees : float | dict[str, float] | array-like of shape (n_assets, ), default=0.0
         Management fees of the assets. It is used to add linear management fees to the
@@ -280,7 +280,7 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
     def _risk(
         self,
         weights: np.ndarray,
-        prior_model: PriorModel,
+        return_distribution: ReturnDistribution,
     ) -> float:
         """Compute the risk measure of a theoretical portfolio defined by the weights
         vector.
@@ -290,8 +290,8 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
         weights : ndarray of shape (n_assets,)
            The vector of weights.
 
-        prior_model : PriorModel
-            The prior model of the assets distribution.
+        return_distribution : ReturnDistribution
+            The assets return distribution.
 
         Returns
         -------
@@ -300,36 +300,39 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
             vector.
         """
         ptf = Portfolio(
-            X=prior_model.returns,
+            X=return_distribution.returns,
+            sample_weight=return_distribution.sample_weight,
             weights=weights,
             transaction_costs=self.transaction_costs,
             management_fees=self.management_fees,
             previous_weights=self.previous_weights,
         )
         if self.risk_measure in [RiskMeasure.VARIANCE, RiskMeasure.STANDARD_DEVIATION]:
-            risk = ptf.variance_from_assets(assets_covariance=prior_model.covariance)
+            risk = ptf.variance_from_assets(
+                assets_covariance=return_distribution.covariance
+            )
             if self.risk_measure == RiskMeasure.STANDARD_DEVIATION:
                 risk = np.sqrt(risk)
         else:
             risk = getattr(ptf, str(self.risk_measure.value))
         return risk
 
-    def _unitary_risks(self, prior_model: PriorModel) -> np.ndarray:
+    def _unitary_risks(self, return_distribution: ReturnDistribution) -> np.ndarray:
         """Compute the vector of risk measure for each single assets.
 
         Parameters
         ----------
-        prior_model : PriorModel
-            The prior model of the assets distribution.
+        return_distribution : ReturnDistribution
+            The asset returns distribution.
 
         Returns
         -------
         values: ndarray of shape (n_assets,)
             The risk measure of each asset.
         """
-        n_assets = prior_model.returns.shape[1]
+        n_assets = return_distribution.returns.shape[1]
         risks = [
-            self._risk(weights=weights, prior_model=prior_model)
+            self._risk(weights=weights, return_distribution=return_distribution)
             for weights in np.identity(n_assets)
         ]
         return np.array(risks)

skfolio/optimization/cluster/hierarchical/_herc.py

@@ -102,7 +102,7 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
 
     prior_estimator : BasePrior, optional
         :ref:`Prior estimator <prior>`.
-        The prior estimator is used to estimate the :class:`~skfolio.prior.PriorModel`
+        The prior estimator is used to estimate the :class:`~skfolio.prior.ReturnDistribution`
         containing the estimation of assets expected returns, covariance matrix and
         returns. The moments and returns estimations are used for the risk computation
         and the returns estimation are used by the distance matrix estimator.
@@ -181,7 +181,7 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
             needs to be homogenous to the periodicity of :math:`\mu`. For example, if
             the input `X` is composed of **daily** returns, the `transaction_costs` need
             to be expressed as **daily** costs.
-            (See :ref:`sphx_glr_auto_examples_1_mean_risk_plot_6_transaction_costs.py`)
+            (See :ref:`sphx_glr_auto_examples_mean_risk_plot_6_transaction_costs.py`)
 
     management_fees : float | dict[str, float] | array-like of shape (n_assets, ), default=0.0
         Management fees of the assets. It is used to add linear management fees to the
@@ -368,8 +368,8 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
 
         # Fit the estimators
         self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
-        prior_model = self.prior_estimator_.prior_model_
-        returns = prior_model.returns
+        return_distribution = self.prior_estimator_.return_distribution_
+        returns = return_distribution.returns
 
         # To keep the asset_names
         if isinstance(X, pd.DataFrame):
@@ -397,7 +397,7 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
 
         min_weights, max_weights = self._convert_weights_bounds(n_assets=n_assets)
 
-        assets_risks = self._unitary_risks(prior_model=prior_model)
+        assets_risks = self._unitary_risks(return_distribution=return_distribution)
         weights = np.ones(n_assets)
         clusters_weights = np.ones(n_clusters)
 
@@ -411,7 +411,7 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
             inv_risk_w[cluster_ids] = 1 / assets_risks[cluster_ids]
             inv_risk_w /= inv_risk_w.sum()
             cluster_risks.append(
-                self._risk(weights=inv_risk_w, prior_model=prior_model)
+                self._risk(weights=inv_risk_w, return_distribution=return_distribution)
             )
             weights[cluster_ids] = inv_risk_w[cluster_ids]
         cluster_risks = np.array(cluster_risks)

skfolio/optimization/cluster/hierarchical/_hrp.py

@@ -78,7 +78,7 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
 
     prior_estimator : BasePrior, optional
         :ref:`Prior estimator <prior>`.
-        The prior estimator is used to estimate the :class:`~skfolio.prior.PriorModel`
+        The prior estimator is used to estimate the :class:`~skfolio.prior.ReturnDistribution`
         containing the estimation of assets expected returns, covariance matrix and
         returns. The moments and returns estimations are used for the risk computation
         and the returns estimation are used by the distance matrix estimator.
@@ -156,7 +156,7 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
             needs to be homogenous to the periodicity of :math:`\mu`. For example, if
             the input `X` is composed of **daily** returns, the `transaction_costs` need
             to be expressed as **daily** costs.
-            (See :ref:`sphx_glr_auto_examples_1_mean_risk_plot_6_transaction_costs.py`)
+            (See :ref:`sphx_glr_auto_examples_mean_risk_plot_6_transaction_costs.py`)
 
     management_fees : float | dict[str, float] | array-like of shape (n_assets, ), default=0.0
         Management fees of the assets. It is used to add linear management fees to the
@@ -320,8 +320,8 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
 
         # Fit the estimators
         self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
-        prior_model = self.prior_estimator_.prior_model_
-        returns = prior_model.returns
+        return_distribution = self.prior_estimator_.return_distribution_
+        returns = return_distribution.returns
 
         # To keep the asset_names
         if isinstance(X, pd.DataFrame):
@@ -344,7 +344,7 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
         n_assets = X.shape[1]
 
         min_weights, max_weights = self._convert_weights_bounds(n_assets=n_assets)
-        assets_risks = self._unitary_risks(prior_model=prior_model)
+        assets_risks = self._unitary_risks(return_distribution=return_distribution)
 
         ordered_linkage_matrix = sch.optimal_leaf_ordering(
             self.hierarchical_clustering_estimator_.linkage_matrix_,
@@ -365,7 +365,9 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
                     inv_risk_w[ids] = 1 / assets_risks[ids]
                     inv_risk_w /= inv_risk_w.sum()
                     risks.append(
-                        self._risk(weights=inv_risk_w, prior_model=prior_model)
+                        self._risk(
+                            weights=inv_risk_w, return_distribution=return_distribution
+                        )
                     )
                 left_risk, right_risk = risks
                 left_cluster, right_cluster = clusters_ids