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

skfolio/optimization/convex/_distributionally_robust.py

@@ -46,7 +46,7 @@ class DistributionallyRobustCVaR(ConvexOptimization):
 
     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,
         returns and Cholesky decomposition of the covariance.
         The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
@@ -124,23 +124,23 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         Linear constraints.
         The linear constraints must match any of following patterns:
 
-           * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
-           * "ref1 >= 2.9 * ref2"
-           * "ref1 == ref2"
-           * "ref1 >= ref1"
+           * `"2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"`
+           * `"ref1 >= 2.9 * ref2"`
+           * `"ref1 == ref2"`
+           * `"ref1 >= ref1"`
 
-        With "ref1", "ref2" ... the assets names or the groups names provided
+        With `"ref1"`, `"ref2"` ... the assets names or the groups names provided
         in the parameter `groups`. Assets names can be referenced without the need of
         `groups` if the input `X` of the `fit` method is a DataFrame with these
         assets names in columns.
 
         For example:
 
-            * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
-            * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US == 0.7" --> the sum of all US weights must be equal to 70%
-            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
-            * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
+            * `"SPX >= 0.10"` --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
+            * `"SX5E + TLT >= 0.2"` --> the sum of SX5E and TLT weights must be greater than 20%
+            * `"US == 0.7"` --> the sum of all US weights must be equal to 70%
+            * `"Equity == 3 * Bond"` --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
+            * `"2*SPX + 3*Europe <= Bond + 0.05"` --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional
         The assets groups referenced in `linear_constraints`.
@@ -150,8 +150,8 @@ class DistributionallyRobustCVaR(ConvexOptimization):
 
         For example:
 
-            * groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}
-            * groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]
+            * `groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}`
+            * `groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]`
 
     left_inequality : array-like of shape (n_constraints, n_assets), optional
         Left inequality matrix :math:`A` of the linear
@@ -343,8 +343,8 @@ class DistributionallyRobustCVaR(ConvexOptimization):
             check_type=BasePrior,
         )
         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
+        return_distribution = self.prior_estimator_.return_distribution_
+        n_observations, n_assets = return_distribution.returns.shape
 
         # set solvers params
         if self.solver == "CLARABEL":
@@ -378,12 +378,16 @@ class DistributionallyRobustCVaR(ConvexOptimization):
             u * self._scale_constraints >= cp.Constant(0),
             v * self._scale_constraints >= cp.Constant(0),
             b1 * tau * self._scale_constraints
-            + a1 * (prior_model.returns @ w) * self._scale_constraints
-            + cp.multiply(u, (1 + prior_model.returns)) @ ones * self._scale_constraints
+            + a1 * (return_distribution.returns @ w) * self._scale_constraints
+            + cp.multiply(u, (1 + return_distribution.returns))
+            @ ones
+            * self._scale_constraints
             <= s * self._scale_constraints,
             b2 * tau * self._scale_constraints
-            + a2 * (prior_model.returns @ w) * self._scale_constraints
-            + cp.multiply(v, (1 + prior_model.returns)) @ ones * self._scale_constraints
+            + a2 * (return_distribution.returns @ w) * self._scale_constraints
+            + cp.multiply(v, (1 + return_distribution.returns))
+            @ ones
+            * self._scale_constraints
             <= s * self._scale_constraints,
         ]
 
@@ -403,9 +407,17 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         custom_objective = self._get_custom_objective(w=w)
         constraints += self._get_custom_constraints(w=w)
 
+        if return_distribution.sample_weight is None:
+            risk = cp.sum(s) / n_observations * self._scale_objective
+        else:
+            risk = (
+                cp.sum(cp.multiply(return_distribution.sample_weight, s))
+                * self._scale_objective
+            )
+
         objective = cp.Minimize(
             cp.Constant(self.wasserstein_ball_radius) * lb * self._scale_objective
-            + (1 / n_observations) * cp.sum(s) * self._scale_objective
+            + risk
             + custom_objective * self._scale_objective
         )
 

skfolio/optimization/convex/_maximum_diversification.py

@@ -29,7 +29,7 @@ class MaximumDiversification(MeanRisk):
     ----------
     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,
         returns and Cholesky decomposition of the covariance.
         The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
@@ -130,7 +130,7 @@ class MaximumDiversification(MeanRisk):
             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
@@ -200,23 +200,23 @@ class MaximumDiversification(MeanRisk):
         Linear constraints.
         The linear constraints must match any of following patterns:
 
-           * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
-           * "ref1 >= 2.9 * ref2"
-           * "ref1 == ref2"
-           * "ref1 >= ref1"
+           * `"2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"`
+           * `"ref1 >= 2.9 * ref2"`
+           * `"ref1 == ref2"`
+           * `"ref1 >= ref1"`
 
-        With "ref1", "ref2" ... the assets names or the groups names provided
+        With `"ref1"`, `"ref2"` ... the assets names or the groups names provided
         in the parameter `groups`. Assets names can be referenced without the need of
         `groups` if the input `X` of the `fit` method is a DataFrame with these
         assets names in columns.
 
         For example:
 
-            * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
-            * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US == 0.7" --> the sum of all US weights must be equal to 70%
-            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
-            * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
+            * `"SPX >= 0.10"` --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
+            * `"SX5E + TLT >= 0.2"` --> the sum of SX5E and TLT weights must be greater than 20%
+            * `"US == 0.7"` --> the sum of all US weights must be equal to 70%
+            * `"Equity == 3 * Bond"` --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
+            * `"2*SPX + 3*Europe <= Bond + 0.05"` --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional
         The assets groups referenced in `linear_constraints`.
@@ -226,8 +226,8 @@ class MaximumDiversification(MeanRisk):
 
         For example:
 
-            * groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}
-            * groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]
+            * `groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}`
+            * `groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]`
 
     left_inequality : array-like of shape (n_constraints, n_assets), optional
         Left inequality matrix :math:`A` of the linear
@@ -256,9 +256,6 @@ class MaximumDiversification(MeanRisk):
     min_return : float | array-like of shape (n_optimization), optional
         Lower bound constraint on the expected return.
 
-    min_return : float | array-like of shape (n_optimization), optional
-        Lower bound constraint on the expected return.
-
     add_objective : Callable[[cp.Variable], cp.Expression], optional
         Add a custom objective to the existing objective expression.
         It is a function that must take as argument the weights `w` and returns a
@@ -429,7 +426,7 @@ class MaximumDiversification(MeanRisk):
 
         def func(w, obj):
             """Weighted volatilities."""
-            covariance = obj.prior_estimator_.prior_model_.covariance
+            covariance = obj.prior_estimator_.return_distribution_.covariance
             return np.sqrt(np.diag(covariance)) @ w
 
         self.overwrite_expected_return = func

skfolio/optimization/convex/_mean_risk.py

@@ -141,7 +141,7 @@ class MeanRisk(ConvexOptimization):
 
     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,
         returns and Cholesky decomposition of the covariance.
         The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
@@ -277,7 +277,7 @@ class MeanRisk(ConvexOptimization):
             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
@@ -369,23 +369,23 @@ class MeanRisk(ConvexOptimization):
         Linear constraints.
         The linear constraints must match any of following patterns:
 
-           * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
-           * "ref1 >= 2.9 * ref2"
-           * "ref1 == ref2"
-           * "ref1 >= ref1"
+           * `"2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"`
+           * `"ref1 >= 2.9 * ref2"`
+           * `"ref1 == ref2"`
+           * `"ref1 >= ref1"`
 
-        With "ref1", "ref2" ... the assets names or the groups names provided
+        With `"ref1"`, `"ref2"` ... the assets names or the groups names provided
         in the parameter `groups`. Assets names can be referenced without the need of
         `groups` if the input `X` of the `fit` method is a DataFrame with these
         assets names in columns.
 
         For example:
 
-            * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
-            * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US == 0.7" --> the sum of all US weights must be equal to 70%
-            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
-            * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
+            * `"SPX >= 0.10"` --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
+            * `"SX5E + TLT >= 0.2"` --> the sum of SX5E and TLT weights must be greater than 20%
+            * `"US == 0.7"` --> the sum of all US weights must be equal to 70%
+            * `"Equity == 3 * Bond"` --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
+            * `"2*SPX + 3*Europe <= Bond + 0.05"` --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional
         The assets groups referenced in `linear_constraints`.
@@ -395,8 +395,8 @@ class MeanRisk(ConvexOptimization):
 
         For example:
 
-            * groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}
-            * groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]
+            * `groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}`
+            * `groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]`
 
     left_inequality : array-like of shape (n_constraints, n_assets), optional
         Left inequality matrix :math:`A` of the linear
@@ -778,8 +778,8 @@ class MeanRisk(ConvexOptimization):
             check_type=BasePrior,
         )
         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
+        return_distribution = self.prior_estimator_.return_distribution_
+        n_observations, n_assets = return_distribution.returns.shape
 
         # set solvers params
         match self.solver:
@@ -874,9 +874,11 @@ class MeanRisk(ConvexOptimization):
 
         # Expected returns
         expected_return = (
-            self._cvx_expected_return(prior_model=prior_model, w=w)
-            - self._cvx_transaction_cost(prior_model=prior_model, w=w, factor=factor)
-            - self._cvx_management_fee(prior_model=prior_model, w=w)
+            self._cvx_expected_return(return_distribution=return_distribution, w=w)
+            - self._cvx_transaction_cost(
+                return_distribution=return_distribution, w=w, factor=factor
+            )
+            - self._cvx_management_fee(return_distribution=return_distribution, w=w)
             - mu_uncertainty_set
         )
 
@@ -898,11 +900,11 @@ class MeanRisk(ConvexOptimization):
                 y = y[y.columns[0]]
             _, y = skv.validate_data(self, X, y)
             tracking_error = self._tracking_error(
-                prior_model=prior_model, w=w, y=y, factor=factor
+                return_distribution=return_distribution, w=w, y=y, factor=factor
             )
             constraints += [
                 tracking_error * self._scale_constraints
-                <= self.max_tracking_error * self._scale_constraints
+                <= self.max_tracking_error * factor * self._scale_constraints
             ]
 
         # Turnover
@@ -977,8 +979,8 @@ class MeanRisk(ConvexOptimization):
 
                 args = {}
                 for arg_name in args_names(risk_func):
-                    if arg_name == "prior_model":
-                        args[arg_name] = prior_model
+                    if arg_name == "return_distribution":
+                        args[arg_name] = return_distribution
                     elif arg_name == "w":
                         args[arg_name] = w
                     elif arg_name == "factor":
@@ -1036,8 +1038,17 @@ class MeanRisk(ConvexOptimization):
                     + custom_objective * self._scale_objective
                 )
             case ObjectiveFunction.MAXIMIZE_RATIO:
+                # Capture common obvious mistake before solver failure to help user
+                if np.isscalar(self.min_weights) and self.min_weights >= 0:
+                    if np.max(return_distribution.mu) - self.risk_free_rate <= 0:
+                        raise ValueError(
+                            "Cannot optimize for Maximum Ratio with your current "
+                            "constraints and input. This is because your assets' "
+                            "expected returns are all under-performing your risk-free "
+                            f"rate {self.risk_free_rate:.2%}."
+                        )
                 homogenization_factor = _optimal_homogenization_factor(
-                    mu=prior_model.mu
+                    mu=return_distribution.mu
                 )
 
                 if expected_return.is_affine():
@@ -1060,7 +1071,6 @@ class MeanRisk(ConvexOptimization):
                     # Fractional Programming Problems".
                     # The condition to work is f1 >= 0, so we need to raise an user
                     # warning when it's not the case.
-                    # TODO: raise user warning when f1<0
 
                     constraints += [
                         expected_return * self._scale_constraints

skfolio/optimization/convex/_risk_budgeting.py

@@ -96,7 +96,7 @@ class RiskBudgeting(ConvexOptimization):
 
     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,
         returns and Cholesky decomposition of the covariance.
         The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
@@ -166,7 +166,7 @@ class RiskBudgeting(ConvexOptimization):
             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
@@ -216,23 +216,23 @@ class RiskBudgeting(ConvexOptimization):
         Linear constraints.
         The linear constraints must match any of following patterns:
 
-           * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
-           * "ref1 >= 2.9 * ref2"
-           * "ref1 == ref2"
-           * "ref1 >= ref1"
+           * `"2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"`
+           * `"ref1 >= 2.9 * ref2"`
+           * `"ref1 == ref2"`
+           * `"ref1 >= ref1"`
 
-        With "ref1", "ref2" ... the assets names or the groups names provided
+        With `"ref1"`, `"ref2"` ... the assets names or the groups names provided
         in the parameter `groups`. Assets names can be referenced without the need of
         `groups` if the input `X` of the `fit` method is a DataFrame with these
         assets names in columns.
 
         For example:
 
-            * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
-            * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US == 0.7" --> the sum of all US weights must be equal to 70%
-            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
-            * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
+            * `"SPX >= 0.10"` --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
+            * `"SX5E + TLT >= 0.2"` --> the sum of SX5E and TLT weights must be greater than 20%
+            * `"US == 0.7"` --> the sum of all US weights must be equal to 70%
+            * `"Equity == 3 * Bond"` --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
+            * `"2*SPX + 3*Europe <= Bond + 0.05"` --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional
         The assets groups referenced in `linear_constraints`.
@@ -242,8 +242,8 @@ class RiskBudgeting(ConvexOptimization):
 
         For example:
 
-            * groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}
-            * groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]
+            * `groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}`
+            * `groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]`
 
     left_inequality : array-like of shape (n_constraints, n_assets), optional
         Left inequality matrix :math:`A` of the linear
@@ -467,8 +467,8 @@ class RiskBudgeting(ConvexOptimization):
             check_type=BasePrior,
         )
         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
+        return_distribution = self.prior_estimator_.return_distribution_
+        n_observations, n_assets = return_distribution.returns.shape
 
         # set solvers params
         if self.solver == "CLARABEL":
@@ -500,9 +500,11 @@ class RiskBudgeting(ConvexOptimization):
 
         # Expected returns
         expected_return = (
-            self._cvx_expected_return(prior_model=prior_model, w=w)
-            - self._cvx_transaction_cost(prior_model=prior_model, w=w, factor=factor)
-            - self._cvx_management_fee(prior_model=prior_model, w=w)
+            self._cvx_expected_return(return_distribution=return_distribution, w=w)
+            - self._cvx_transaction_cost(
+                return_distribution=return_distribution, w=w, factor=factor
+            )
+            - self._cvx_management_fee(return_distribution=return_distribution, w=w)
         )
 
         # risk budgeting constraint
@@ -531,8 +533,8 @@ class RiskBudgeting(ConvexOptimization):
         risk_func = getattr(self, f"_{self.risk_measure.value}_risk")
         args = {}
         for arg_name in args_names(risk_func):
-            if arg_name == "prior_model":
-                args[arg_name] = prior_model
+            if arg_name == "return_distribution":
+                args[arg_name] = return_distribution
             elif arg_name == "w":
                 args[arg_name] = w
             elif arg_name == "factor":

skfolio/optimization/ensemble/__init__.py

@@ -1,8 +1,6 @@
 """Ensemble Optimization module."""
 
-from skfolio.optimization.ensemble._stacking import (
-    BaseComposition,
-    StackingOptimization,
-)
+from skfolio.optimization.ensemble._stacking import StackingOptimization
+from skfolio.utils.composition import BaseComposition
 
 __all__ = ["BaseComposition", "StackingOptimization"]

skfolio/optimization/ensemble/_stacking.py

@@ -23,7 +23,7 @@ from skfolio.measures import RatioMeasure
 from skfolio.model_selection import BaseCombinatorialCV, cross_val_predict
 from skfolio.optimization._base import BaseOptimization
 from skfolio.optimization.convex import MeanRisk
-from skfolio.optimization.ensemble._base import BaseComposition
+from skfolio.utils.composition import BaseComposition
 from skfolio.utils.tools import check_estimator, fit_single_estimator
 
 

skfolio/optimization/naive/_naive.py

@@ -25,7 +25,7 @@ class InverseVolatility(BaseOptimization):
     ----------
     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,
         returns and Cholesky decomposition of the covariance.
         The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
@@ -98,7 +98,7 @@ class InverseVolatility(BaseOptimization):
             check_type=BasePrior,
         )
         self.prior_estimator_.fit(X, y, **routed_params.prior_estimator.fit)
-        covariance = self.prior_estimator_.prior_model_.covariance
+        covariance = self.prior_estimator_.return_distribution_.covariance
         w = 1 / np.sqrt(np.diag(covariance))
         self.weights_ = w / sum(w)
         return self

skfolio/population/_population.py

@@ -14,11 +14,11 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 import scipy.interpolate as sci
-import scipy.stats as st
 
 import skfolio.typing as skt
 from skfolio.measures import RatioMeasure
 from skfolio.portfolio import BasePortfolio, MultiPeriodPortfolio
+from skfolio.utils.figure import kde_trace
 from skfolio.utils.sorting import non_denominated_sort
 from skfolio.utils.tools import deduplicate_names, optimal_rounding_decimals
 
@@ -940,23 +940,44 @@ class Population(list):
         )
         return fig
 
-    def plot_returns_distribution(self) -> go.Figure:
+    def plot_returns_distribution(
+        self, percentile_cutoff: float | None = None
+    ) -> go.Figure:
         """Plot the Portfolios returns distribution using Gaussian KDE.
 
+        Parameters
+        ----------
+        percentile_cutoff : float, default=None
+            Percentile cutoff for tail truncation (percentile), in percent.
+            If a float p is provided, the distribution support is truncated at the p-th
+            and (100 - p)-th percentiles.
+            If None, no truncation is applied (uses full min/max of returns).
+
         Returns
         -------
         plot : Figure
             Returns the plot Figure object
         """
-        traces = []
-        for ptf in self:
-            lower = np.percentile(ptf.returns, 1e-1)
-            upper = np.percentile(ptf.returns, 100 - 1e-1)
-            x = np.linspace(lower, upper, 500)
-            y = st.gaussian_kde(ptf.returns)(x)
+        traces: list[go.Scatter] = []
+        colors = px.colors.qualitative.Plotly
+
+        for i, ptf in enumerate(self):
+            color = colors[i % len(colors)]
+            returns = ptf.returns
             traces.append(
-                go.Scatter(x=x, y=y, mode="lines", fill="tozeroy", name=ptf.name)
+                kde_trace(
+                    x=returns,
+                    sample_weight=ptf.sample_weight,
+                    percentile_cutoff=percentile_cutoff,
+                    name=ptf.name,
+                    line_color=color,
+                    fill_opacity=0.3,
+                    line_dash="solid",
+                    line_width=1,
+                    visible=True,
+                )
             )
+
         fig = go.Figure(traces)
         fig.update_layout(
             title="Returns Distribution",