skfolio 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

skfolio/cluster/_hierarchical.py

@@ -149,6 +149,7 @@ class HierarchicalClustering(skb.ClusterMixin, skb.BaseEstimator):
     .. [1] "Application of two-order difference to gap statistic".
         Yue, Wang & Wei (2009)
     """
+
     n_clusters_: int
     labels_: np.ndarray
     linkage_matrix_: np.ndarray

skfolio/datasets/_base.py

@@ -136,7 +136,7 @@ def download_dataset(
         representing the asset price of a given observation.
     """
     url = (
-        "https://github.com/HugoDelatte/portfolio-optimization/raw/main/datasets/"
+        "https://github.com/skfolio/skfolio/raw/main/datasets/"
         f"{data_filename}.csv.gz"
     )
 

skfolio/measures/__init__.py

@@ -25,9 +25,9 @@ from skfolio.measures._measures import (
     get_drawdowns,
     gini_mean_difference,
     kurtosis,
-    mean_absolute_deviation,
     max_drawdown,
     mean,
+    mean_absolute_deviation,
     owa_gmd_weights,
     semi_deviation,
     semi_variance,

skfolio/model_selection/_combinatorial.py

@@ -316,20 +316,18 @@ class CombinatorialPurgedCV(BaseCombinatorialCV):
 
     def summary(self, X) -> pd.Series:
         n_samples = X.shape[0]
-        return pd.Series(
-            {
-                "Number of Observations": n_samples,
-                "Total Number of Folds": self.n_folds,
-                "Number of Test Folds": self.n_test_folds,
-                "Purge Size": self.purged_size,
-                "Embargo Size": self.embargo_size,
-                "Average Training Size": int(
-                    n_samples / self.n_folds * (self.n_folds - self.n_test_folds)
-                ),
-                "Number of Test Paths": self.n_test_paths,
-                "Number of Training Combinations": self.n_splits,
-            }
-        )
+        return pd.Series({
+            "Number of Observations": n_samples,
+            "Total Number of Folds": self.n_folds,
+            "Number of Test Folds": self.n_test_folds,
+            "Purge Size": self.purged_size,
+            "Embargo Size": self.embargo_size,
+            "Average Training Size": int(
+                n_samples / self.n_folds * (self.n_folds - self.n_test_folds)
+            ),
+            "Number of Test Paths": self.n_test_paths,
+            "Number of Training Combinations": self.n_splits,
+        })
 
     def plot_train_test_folds(self) -> skt.Figure:
         """Plot the train/test fold locations"""

skfolio/model_selection/_validation.py

@@ -165,14 +165,12 @@ def cross_val_predict(
                 path_id = path_ids[i, j]
                 portfolios[path_id].append(p)
         name = portfolio_params.pop("name", "path")
-        pred = Population(
-            [
-                MultiPeriodPortfolio(
-                    name=f"{name}_{i}", portfolios=portfolios[i], **portfolio_params
-                )
-                for i in range(path_nb)
-            ]
-        )
+        pred = Population([
+            MultiPeriodPortfolio(
+                name=f"{name}_{i}", portfolios=portfolios[i], **portfolio_params
+            )
+            for i in range(path_nb)
+        ])
     else:
         # We need to re-order the test folds in case they were un-ordered by the
         # CV generator.

skfolio/moments/covariance/_covariance.py

@@ -1,6 +1,5 @@
 """Covariance Estimators."""
 
-
 import numpy as np
 import numpy.typing as npt
 import pandas as pd

skfolio/moments/expected_returns/_expected_returns.py

@@ -315,6 +315,7 @@ class ShrunkMu(BaseMu):
     .. [3] "Optimal shrinkage estimator for high-dimensional mean vector"
         Bodnar, Okhrin and Parolya (2019)
     """
+
     covariance_estimator_: BaseCovariance
     mu_target_: np.ndarray
     alpha_: float

skfolio/optimization/_base.py

@@ -89,17 +89,15 @@ class BaseOptimization(skb.BaseEstimator, ABC):
         # For a 2D array we return a population of portfolios.
         if self.weights_.ndim == 2:
             n_portfolios = self.weights_.shape[0]
-            return Population(
-                [
-                    Portfolio(
-                        X=X,
-                        weights=self.weights_[i],
-                        name=f"ptf{i} - {name}",
-                        **ptf_kwargs,
-                    )
-                    for i in range(n_portfolios)
-                ]
-            )
+            return Population([
+                Portfolio(
+                    X=X,
+                    weights=self.weights_[i],
+                    name=f"ptf{i} - {name}",
+                    **ptf_kwargs,
+                )
+                for i in range(n_portfolios)
+            ])
         return Portfolio(X=X, weights=self.weights_, name=name, **ptf_kwargs)
 
     def score(self, X: npt.ArrayLike, y: npt.ArrayLike = None) -> float:

skfolio/optimization/cluster/hierarchical/_base.py

@@ -7,14 +7,12 @@ from abc import ABC, abstractmethod
 
 import numpy as np
 import numpy.typing as npt
-import pandas as pd
 
 import skfolio.typing as skt
 from skfolio.cluster import HierarchicalClustering
 from skfolio.distance import BaseDistance
 from skfolio.measures import ExtraRiskMeasure, RiskMeasure
 from skfolio.optimization._base import BaseOptimization
-from skfolio.population import Population
 from skfolio.portfolio import Portfolio
 from skfolio.prior import BasePrior, PriorModel
 from skfolio.utils.tools import input_to_array

skfolio/optimization/convex/__init__.py

@@ -13,4 +13,4 @@ __all__ = [
     "RiskBudgeting",
     "DistributionallyRobustCVaR",
     "MaximumDiversification",
-]
+]

skfolio/optimization/convex/_base.py

@@ -46,6 +46,7 @@ class ObjectiveFunction(AutoEnum):
     MAXIMIZE_UTILITY : str
         Maximize the ratio  :math:`\frac{w^T\mu - R_{f}}{risk(w)}`.
     """
+
     MINIMIZE_RISK = auto()
     MAXIMIZE_RETURN = auto()
     MAXIMIZE_UTILITY = auto()
@@ -364,14 +365,17 @@ class ConvexOptimization(BaseOptimization, ABC):
         It is a function that must take as argument the weights `w` and returns a
         CVPXY expression.
 
-    solver : str, optional
-        The solver to use. For example, "ECOS", "SCS", or "OSQP".
-        The default (`None`) is set depending on the problem.
+    solver : str, default="CLARABEL"
+        The solver to use. The default is "CLARABEL" which is written in Rust and has
+        better numerical stability and performance than ECOS and SCS. Cvxpy will replace
+        its default solver "ECOS" by "CLARABEL" in future releases.
         For more details about available solvers, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
 
     solver_params : dict, optional
         Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is use `{"tol_gap_abs": 1e-9, "tol_gap_rel": 1e-9}`
+        for the solver "CLARABEL" and the CVXPY default otherwise.
         For more details about solver arguments, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
 
@@ -385,6 +389,10 @@ class ConvexOptimization(BaseOptimization, ABC):
         It can be used to increase the optimization accuracies in specific cases.
         The default (`None`) is set depending on the problem.
 
+    save_problem : bool, default=False
+        If this is set to True, the CVXPY Problem is saved in `problem_`.
+        The default is `False`.
+
     raise_on_failure : bool, default=True
         If this is set to True, an error is raised when the optimization fail otherwise
         it passes with a warning.
@@ -400,9 +408,6 @@ class ConvexOptimization(BaseOptimization, ABC):
     weights_ : ndarray of shape (n_assets,) or (n_optimizations, n_assets)
         Weights of the assets.
 
-    problem_: cvxpy.Problem
-        CVXPY problem used for the optimization.
-
     problem_values_ :  dict[str, float] | list[dict[str, float]] of size n_optimizations
         Expression values retrieved from the CVXPY problem.
 
@@ -414,12 +419,17 @@ class ConvexOptimization(BaseOptimization, ABC):
 
     covariance_uncertainty_set_estimator_ : BaseCovarianceUncertaintySet
         Fitted `covariance_uncertainty_set_estimator` if provided.
+
+    problem_: cvxpy.Problem
+        CVXPY problem used for the optimization. Only when `save_problem` is set to
+        `True`.
     """
-    _solver: str
+
+    _solver_params: dict
     _scale_objective: cp.Constant
     _scale_constraints: cp.Constant
+    _cvx_cache: dict
 
-    _cvx_cache = dict
     problem_: cp.Problem
     problem_values_: dict[str, float] | list[dict[str, float]]
     prior_estimator_: BasePrior
@@ -448,18 +458,20 @@ class ConvexOptimization(BaseOptimization, ABC):
         l1_coef: float = 0.0,
         l2_coef: float = 0.0,
         mu_uncertainty_set_estimator: BaseMuUncertaintySet | None = None,
-        covariance_uncertainty_set_estimator: BaseCovarianceUncertaintySet
-        | None = None,
+        covariance_uncertainty_set_estimator: (
+            BaseCovarianceUncertaintySet | None
+        ) = None,
         risk_free_rate: float = 0.0,
         min_acceptable_return: skt.Target | None = None,
         cvar_beta: float = 0.95,
         evar_beta: float = 0.95,
         cdar_beta: float = 0.95,
         edar_beta: float = 0.95,
-        solver: str | None = None,
+        solver: str = "CLARABEL",
         solver_params: dict | None = None,
         scale_objective: float | None = None,
         scale_constraints: float | None = None,
+        save_problem: bool = False,
         raise_on_failure: bool = True,
         add_objective: skt.ExpressionFunction | None = None,
         add_constraints: skt.ExpressionFunction | None = None,
@@ -501,6 +513,7 @@ class ConvexOptimization(BaseOptimization, ABC):
         self.overwrite_expected_return = overwrite_expected_return
         self.solver = solver
         self.solver_params = solver_params
+        self.save_problem = save_problem
         self.raise_on_failure = raise_on_failure
         self.scale_objective = scale_objective
         self.scale_constraints = scale_constraints
@@ -509,6 +522,8 @@ class ConvexOptimization(BaseOptimization, ABC):
         self.cdar_beta = cdar_beta
         self.edar_beta = edar_beta
 
+        self._clear_models_cache()
+
     def _call_custom_func(
         self, func: skt.ExpressionFunction, w: cp.Variable, name: str = "custom_func"
     ) -> cp.Expression | list[cp.Expression]:
@@ -757,21 +772,19 @@ class ConvexOptimization(BaseOptimization, ABC):
 
         return constraints
 
-    def _set_solver(self, default: str) -> None:
-        """Set solver by saving its value in `_solver`.
+    def _set_solver_params(self, default: dict | None) -> None:
+        """Set the solver params by saving its value in `_solver_params`.
         It uses `solver` if provided otherwise it uses the `default` solver.
 
         Parameters
         ----------
         default : str
-            The default solver to use when `solver` is `None`.
+            The default solver params to use when `solver_params` is `None`.
         """
-        if self.solver is None:
-            self._solver = default
+        if self.solver_params is None:
+            self._solver_params = default if default is not None else {}
         else:
-            self._solver = self.solver
-        if self._solver not in INSTALLED_SOLVERS:
-            raise ValueError(f"The solver {self._solver} is not installed.")
+            self._solver_params = self.solver_params
 
     def _set_scale_objective(self, default: float) -> None:
         """Set the objective scale by saving its value in `_scale_objective`.
@@ -894,6 +907,9 @@ class ConvexOptimization(BaseOptimization, ABC):
         factor: cvxpy Variable | cvxpy Constant
            CVXPY Variable or Constant used for RatioMeasure optimization problems.
         """
+        if self.solver not in INSTALLED_SOLVERS:
+            raise ValueError(f"The solver {self.solver} is not installed.")
+
         if parameters_values is None:
             parameters_values = []
 
@@ -918,9 +934,7 @@ class ConvexOptimization(BaseOptimization, ABC):
                 for p, v in parameters_values
             ]
 
-        solver_params = self.solver_params
-        if solver_params is None:
-            solver_params = {}
+
         all_weights = []
         all_problem_values = []
         optimal = True
@@ -932,7 +946,7 @@ class ConvexOptimization(BaseOptimization, ABC):
                 # We suppress cvxpy warning as it is redundant with our warning
                 with warnings.catch_warnings():
                     warnings.simplefilter("ignore")
-                    problem.solve(solver=self._solver, **solver_params)
+                    problem.solve(solver=self.solver, **self._solver_params)
 
                 if w.value is None:
                     raise cp.SolverError("No solution found")
@@ -965,7 +979,7 @@ class ConvexOptimization(BaseOptimization, ABC):
                 if len(params_string) != 0:
                     params_string = f" with parameters {params_string}"
                 msg = (
-                    f"Solver '{self._solver}' failed{params_string}. Try another"
+                    f"Solver '{self.solver}' failed for {params_string}. Try another"
                     " solver, or solve with solver_params=dict(verbose=True) for more"
                     " information"
                 )
@@ -988,7 +1002,10 @@ class ConvexOptimization(BaseOptimization, ABC):
             self.weights_ = np.array(all_weights, dtype=float)
             self.problem_values_ = all_problem_values
 
-        self.problem_ = problem
+        if self.save_problem:
+            self.problem_ = problem
+
+        self._clear_models_cache()
 
     @cache_method("_cvx_cache")
     def _cvx_mu_uncertainty_set(
@@ -1893,7 +1910,7 @@ class ConvexOptimization(BaseOptimization, ABC):
         The Gini mean difference (GMD) is a measure of dispersion introduced in the
         context of portfolio optimization by Yitzhaki (1982).
         The initial formulation was not used by practitioners due to the high number of
-        variables that increases proportional to T(T−1)/2 ,
+        variables that increases proportional to T(T-1)/2 ,
 
         Cajas (2021) proposed an alternative reformulation based on the ordered weighted
         averaging (OWA) operator for monotonic weights proposed by Chassein and

skfolio/optimization/convex/_distributionally_robust.py

@@ -172,14 +172,17 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         It is a function that must take as argument the weights `w` and returns a
         CVPXY expression.
 
-    solver : str, optional
-        The solver to use. For example, "ECOS", "SCS", or "OSQP".
-        The default (`None`) is set depending on the problem.
+    solver : str, default="CLARABEL"
+        The solver to use. The default is "CLARABEL" which is written in Rust and has
+        better numerical stability and performance than ECOS and SCS. Cvxpy will replace
+        its default solver "ECOS" by "CLARABEL" in future releases.
         For more details about available solvers, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
 
     solver_params : dict, optional
         Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is use `{"tol_gap_abs": 1e-9, "tol_gap_rel": 1e-9}`
+        for the solver "CLARABEL" and the CVXPY default otherwise.
         For more details about solver arguments, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
 
@@ -193,6 +196,10 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         It can be used to increase the optimization accuracies in specific cases.
         The default (`None`) is set depending on the problem.
 
+    save_problem : bool, default=False
+        If this is set to True, the CVXPY Problem is saved in `problem_`.
+        The default is `False`.
+
     raise_on_failure : bool, default=True
         If this is set to True, an error is raised when the optimization fail otherwise
         it passes with a warning.
@@ -208,15 +215,16 @@ class DistributionallyRobustCVaR(ConvexOptimization):
     weights_ : ndarray of shape (n_assets,) or (n_optimizations, n_assets)
         Weights of the assets.
 
-    problem_: cvxpy.Problem
-        CVXPY problem used for the optimization.
-
     problem_values_ :  dict[str, float] | list[dict[str, float]] of size n_optimizations
         Expression values retrieved from the CVXPY problem.
 
     prior_estimator_ : BasePrior
         Fitted `prior_estimator`.
 
+    problem_: cvxpy.Problem
+        CVXPY problem used for the optimization. Only when `save_problem` is set to
+        `True`.
+
     n_features_in_ : int
         Number of assets seen during `fit`.
 
@@ -252,10 +260,11 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         left_inequality: skt.Inequality | None = None,
         right_inequality: skt.Inequality | None = None,
         risk_free_rate: float = 0.0,
-        solver: str | None = None,
+        solver: str = "CLARABEL",
         solver_params: dict | None = None,
         scale_objective: float | None = None,
         scale_constraints: float | None = None,
+        save_problem: bool = False,
         raise_on_failure: bool = True,
         add_objective: skt.ExpressionFunction | None = None,
         add_constraints: skt.ExpressionFunction | None = None,
@@ -282,6 +291,7 @@ class DistributionallyRobustCVaR(ConvexOptimization):
             solver_params=solver_params,
             scale_objective=scale_objective,
             scale_constraints=scale_constraints,
+            save_problem=save_problem,
             raise_on_failure=raise_on_failure,
             add_objective=add_objective,
             add_constraints=add_constraints,
@@ -313,7 +323,6 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         self._check_feature_names(X, reset=True)
         # Used to avoid adding multiple times similar constrains linked to identical
         # risk models
-        self._clear_models_cache()
         self.prior_estimator_ = check_estimator(
             self.prior_estimator,
             default=EmpiricalPrior(),
@@ -323,8 +332,11 @@ class DistributionallyRobustCVaR(ConvexOptimization):
         prior_model = self.prior_estimator_.prior_model_
         n_observations, n_assets = prior_model.returns.shape
 
-        # set solvers
-        self._set_solver(default="ECOS")
+        # set solvers params
+        if self.solver == "CLARABEL":
+            self._set_solver_params(default={"tol_gap_abs": 1e-9, "tol_gap_rel": 1e-9})
+        else:
+            self._set_solver_params(default=None)
 
         # set scale
         self._set_scale_objective(default=1)

skfolio/optimization/convex/_maximum_diversification.py

@@ -267,14 +267,17 @@ class MaximumDiversification(MeanRisk):
         It is a function that must take as argument the weights `w` and returns a
         CVPXY expression or a list of CVPXY expressions.
 
-    solver : str, optional
-        The solver to use. For example, "ECOS", "SCS", or "OSQP".
-        The default (`None`) is set depending on the problem.
+    solver : str, default="CLARABEL"
+        The solver to use. The default is "CLARABEL" which is written in Rust and has
+        better numerical stability and performance than ECOS and SCS. Cvxpy will replace
+        its default solver "ECOS" by "CLARABEL" in future releases.
         For more details about available solvers, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
 
     solver_params : dict, optional
         Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is use `{"tol_gap_abs": 1e-9, "tol_gap_rel": 1e-9}`
+        for the solver "CLARABEL" and the CVXPY default otherwise.
         For more details about solver arguments, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
 
@@ -288,6 +291,10 @@ class MaximumDiversification(MeanRisk):
         It can be used to increase the optimization accuracies in specific cases.
         The default (`None`) is set depending on the problem.
 
+    save_problem : bool, default=False
+        If this is set to True, the CVXPY Problem is saved in `problem_`.
+        The default is `False`.
+
     raise_on_failure : bool, default=True
         If this is set to True, an error is raised when the optimization fail otherwise
         it passes with a warning.
@@ -303,15 +310,16 @@ class MaximumDiversification(MeanRisk):
     weights_ : ndarray of shape (n_assets,) or (n_optimizations, n_assets)
         Weights of the assets.
 
-    problem_: cvxpy.Problem
-        CVXPY problem used for the optimization.
-
     problem_values_ :  dict[str, float] | list[dict[str, float]] of size n_optimizations
         Expression values retrieved from the CVXPY problem.
 
     prior_estimator_ : BasePrior
         Fitted `prior_estimator`.
 
+    problem_: cvxpy.Problem
+        CVXPY problem used for the optimization. Only when `save_problem` is set to
+        `True`.
+
     n_features_in_ : int
         Number of assets seen during `fit`.
 
@@ -343,10 +351,11 @@ class MaximumDiversification(MeanRisk):
         min_return: skt.Target | None = None,
         max_tracking_error: skt.Target | None = None,
         max_turnover: skt.Target | None = None,
-        solver: str | None = None,
+        solver: str = "CLARABEL",
         solver_params: dict | None = None,
         scale_objective: float | None = None,
         scale_constraints: float | None = None,
+        save_problem: bool = False,
         raise_on_failure: bool = True,
         add_objective: skt.ExpressionFunction | None = None,
         add_constraints: skt.ExpressionFunction | None = None,
@@ -380,6 +389,7 @@ class MaximumDiversification(MeanRisk):
             solver_params=solver_params,
             scale_objective=scale_objective,
             scale_constraints=scale_constraints,
+            save_problem=save_problem,
             raise_on_failure=raise_on_failure,
             add_objective=add_objective,
             add_constraints=add_constraints,

skfolio/optimization/convex/_mean_risk.py

@@ -472,14 +472,17 @@ class MeanRisk(ConvexOptimization):
         It is a function that must take as argument the weights `w` and returns a
         CVPXY expression.
 
-    solver : str, optional
-        The solver to use. For example, "ECOS", "SCS", or "OSQP".
-        The default (`None`) is set depending on the problem.
+    solver : str, default="CLARABEL"
+        The solver to use. The default is "CLARABEL" which is written in Rust and has
+        better numerical stability and performance than ECOS and SCS. Cvxpy will replace
+        its default solver "ECOS" by "CLARABEL" in future releases.
         For more details about available solvers, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
 
     solver_params : dict, optional
         Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is use `{"tol_gap_abs": 1e-9, "tol_gap_rel": 1e-9}`
+        for the solver "CLARABEL" and the CVXPY default otherwise.
         For more details about solver arguments, check the CVXPY documentation:
         https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
 
@@ -493,6 +496,10 @@ class MeanRisk(ConvexOptimization):
         It can be used to increase the optimization accuracies in specific cases.
         The default (`None`) is set depending on the problem.
 
+    save_problem : bool, default=False
+        If this is set to True, the CVXPY Problem is saved in `problem_`.
+        The default is `False`.
+
     raise_on_failure : bool, default=True
         If this is set to True, an error is raised when the optimization fail otherwise
         it passes with a warning.
@@ -508,9 +515,6 @@ class MeanRisk(ConvexOptimization):
     weights_ : ndarray of shape (n_assets,) or (n_optimizations, n_assets)
         Weights of the assets.
 
-    problem_: cvxpy.Problem
-        CVXPY problem used for the optimization.
-
     problem_values_ :  dict[str, float] | list[dict[str, float]] of size n_optimizations
         Expression values retrieved from the CVXPY problem.
 
@@ -523,6 +527,10 @@ class MeanRisk(ConvexOptimization):
     covariance_uncertainty_set_estimator_ : BaseCovarianceUncertaintySet
         Fitted `covariance_uncertainty_set_estimator` if provided.
 
+    problem_: cvxpy.Problem
+        CVXPY problem used for the optimization. Only when `save_problem` is set to
+        `True`.
+
     n_features_in_ : int
         Number of assets seen during `fit`.
 
@@ -555,8 +563,9 @@ class MeanRisk(ConvexOptimization):
         l1_coef: float = 0.0,
         l2_coef: float = 0.0,
         mu_uncertainty_set_estimator: BaseMuUncertaintySet | None = None,
-        covariance_uncertainty_set_estimator: BaseCovarianceUncertaintySet
-        | None = None,
+        covariance_uncertainty_set_estimator: (
+            BaseCovarianceUncertaintySet | None
+        ) = None,
         risk_free_rate: float = 0.0,
         min_return: skt.Target | None = None,
         max_tracking_error: skt.Target | None = None,
@@ -581,10 +590,11 @@ class MeanRisk(ConvexOptimization):
         evar_beta: float = 0.95,
         cdar_beta: float = 0.95,
         edar_beta: float = 0.95,
-        solver: str | None = None,
+        solver: str = "CLARABEL",
         solver_params: dict | None = None,
         scale_objective: float | None = None,
         scale_constraints: float | None = None,
+        save_problem: bool = False,
         raise_on_failure: bool = True,
         add_objective: skt.ExpressionFunction | None = None,
         add_constraints: skt.ExpressionFunction | None = None,
@@ -622,6 +632,7 @@ class MeanRisk(ConvexOptimization):
             solver_params=solver_params,
             scale_objective=scale_objective,
             scale_constraints=scale_constraints,
+            save_problem=save_problem,
             raise_on_failure=raise_on_failure,
             add_objective=add_objective,
             add_constraints=add_constraints,
@@ -689,7 +700,6 @@ class MeanRisk(ConvexOptimization):
         self._validation()
         # Used to avoid adding multiple times similar constrains linked to identical
         # risk models
-        self._clear_models_cache()
         self.prior_estimator_ = check_estimator(
             self.prior_estimator,
             default=EmpiricalPrior(),
@@ -699,8 +709,11 @@ class MeanRisk(ConvexOptimization):
         prior_model = self.prior_estimator_.prior_model_
         n_observations, n_assets = prior_model.returns.shape
 
-        # set solvers
-        self._set_solver(default="ECOS")
+        # set solvers params
+        if self.solver == "CLARABEL":
+            self._set_solver_params(default={"tol_gap_abs": 1e-9, "tol_gap_rel": 1e-9})
+        else:
+            self._set_solver_params(default=None)
 
         # set scales
         if self.objective_function == ObjectiveFunction.MAXIMIZE_RATIO:
@@ -868,7 +881,6 @@ class MeanRisk(ConvexOptimization):
                     elif arg_name == "factor":
                         args[arg_name] = factor
                     elif arg_name == "covariance_uncertainty_set":
-                        self._set_solver(default="CVXOPT")
                         # noinspection PyTypeChecker
                         self.covariance_uncertainty_set_estimator_ = sk.clone(
                             self.covariance_uncertainty_set_estimator