skfolio

https://skfolio.org/
Admin
A Python library for portfolio optimization and risk management built on scikit-learn, offering...
Tokens:812,347
Snippets:5,650
Trust Score:5.5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Portfolio search output example

Source: https://skfolio.org/auto_examples/online_learning/plot_3_online_portfolio_optimization_evaluation.html

Example output showing the best parameters and score for a portfolio search.

```none
Best params: {'objective_function': MINIMIZE_RISK, 'prior_estimator__covariance_estimator__corr_half_life': 40, 'prior_estimator__covariance_estimator__half_life': 60}
Best score (Annualized Sharpe): 0.966177
```

--------------------------------

### Initialize ChangeToScale

Source: https://skfolio.org/_modules/skfolio/descriptor/_growth/_base/_change_to_scale.html

Examples of initializing the ChangeToScale descriptor for different financial metrics.

```python
>>> from skfolio.descriptor import ChangeToScale
>>>
>>> # Earnings change to price (equivalent to EarningsChangeToPrice)
>>> earnings_chg = ChangeToScale("net_income_ttm", "market_cap", lag=12)
>>>
>>> # Capex change to total assets
>>> capex_chg = ChangeToScale("capex_ttm", "total_assets", lag=12)
```

--------------------------------

### LogMarketCap Usage Example

Source: https://skfolio.org/_modules/skfolio/descriptor/_size/_log_market_cap.html

Demonstrates how to initialize the LogMarketCap descriptor and apply it to synthetic characteristic data.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import LogMarketCap
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = LogMarketCap()
>>> log_market_cap = descriptor.fit_transform(X)
```

--------------------------------

### Return on Assets Usage Example

Source: https://skfolio.org/_modules/skfolio/descriptor/_profitability/_return_on_assets.html

Demonstrates how to initialize the ReturnOnAssets descriptor and apply it to synthetic asset characteristics.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import ReturnOnAssets
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = ReturnOnAssets()
>>> return_on_assets = descriptor.fit_transform(X)
```

--------------------------------

### Initialize OnlineGridSearch

Source: https://skfolio.org/auto_examples/online_learning/plot_2_online_hyperparameter_tuning.html

Example instantiation of the OnlineGridSearch estimator with specific parameter grids and scoring functions.

```python
OnlineGridSearch(estimator=RegimeAdjustedEWCovariance(), n_jobs=-1,
                 param_grid={'corr_half_life': [40, 80],
                             'half_life': [20, 40, 60],
                             'regime_half_life': [10, 20]},
                 scoring=make_scorer(portfolio_variance_qlike_loss, greater_is_better=False, response_method=None),
                 test_size=5)
```

--------------------------------

### SalesGrowthRate Usage Example

Source: https://skfolio.org/_modules/skfolio/descriptor/_growth/_sales_growth_rate.html

Demonstrates how to initialize and use the SalesGrowthRate descriptor with synthetic data.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import SalesGrowthRate
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = SalesGrowthRate(lag=252)
>>> sales_growth_rate = descriptor.fit_transform(X)
```

--------------------------------

### MarketLeverage Usage Example

Source: https://skfolio.org/_modules/skfolio/descriptor/_leverage/_market_leverage.html

Demonstrates how to initialize the MarketLeverage descriptor and apply it to a synthetic asset panel.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import MarketLeverage
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = MarketLeverage()
>>> market_leverage = descriptor.fit_transform(X)
```

--------------------------------

### EWCovariance Usage Examples

Source: https://skfolio.org/_modules/skfolio/moments/covariance/_ew_covariance.html

Demonstrates batch fitting, streaming updates with partial_fit, and NaN-aware fitting using an active mask.

```python
>>> import numpy as np
>>> from skfolio.datasets import load_sp500_dataset
>>> from skfolio.moments import EWCovariance
>>> from skfolio.preprocessing import prices_to_returns
>>>
>>> prices = load_sp500_dataset()
>>> X = prices_to_returns(prices)
>>>
>>> # Batch fitting
>>> model = EWCovariance(half_life=40)
>>> model.fit(X)
>>> print(model.covariance_.shape)
>>>
>>> # Streaming updates with partial_fit
>>> model2 = EWCovariance(half_life=20)
>>> model2.partial_fit(X[:100])  # Initial fit
>>> model2.partial_fit(X[100:200])  # Update with new data
>>> model2.partial_fit(X[200:])  # Continue updating
>>>
>>> # NaN-aware fitting with active_mask
>>> # Asset 2 is listed starting from observation 50
>>> active_mask = np.ones(X.shape, dtype=bool)
>>> active_mask[:50, 2] = False
>>> X_nan = X.copy()
>>> X_nan[:50, 2] = np.nan
>>> model3 = EWCovariance(half_life=40)
>>> model3.fit(X_nan, active_mask=active_mask)
```

--------------------------------

### fit(X, y=None)

Source: https://skfolio.org/llms-full.txt

Run the SelectNonExpiring transformer and get the appropriate assets.

```APIDOC
## fit(X, y=None)

### Description
Run the SelectNonExpiring transformer and get the appropriate assets.

### Parameters
- **X** (array-like) - Required - Returns of the assets.
- **y** (None) - Optional - Not used, present for API consistency by convention.

### Returns
- **self** (estimator) - Fitted estimator.
```

--------------------------------

### Configure RiskBudgeting models

Source: https://skfolio.org/

Examples of RiskBudgeting configurations using different risk measures and covariance estimators.

```python
model = RiskBudgeting(risk_measure=RiskMeasure.CVAR)
```

```python
model = RiskBudgeting(
    prior_estimator=EmpiricalPrior(covariance_estimator=GerberCovariance())
)
```

--------------------------------

### Define Asset Groups

Source: https://skfolio.org/llms-full.txt

Examples of defining asset groups for use in linear constraints.

```python
groups = {"SX5E": ["Equity", "Europe"], "SPX": ["Equity", "US"], "TLT": ["Bond", "US"]}
```

```python
groups = [["Equity", "Equity", "Bond"], ["Europe", "US", "US"]]
```

--------------------------------

### Initialize GrowthRate descriptors

Source: https://skfolio.org/_modules/skfolio/descriptor/_growth/_base/_growth_rate.html

Examples of initializing the GrowthRate descriptor for different financial fields with a 252-day lag.

```python
>>> from skfolio.descriptor import GrowthRate
>>>
>>> # 1-year sales growth
>>> sales_growth = GrowthRate("sales_ttm", lag=252)
>>>
>>> # 1-year asset growth
>>> asset_growth = GrowthRate("total_assets", lag=252)
>>>
>>> # 1-year share issuance growth
>>> issuance_growth = GrowthRate("adj_shares_outstanding", lag=252)
```

--------------------------------

### Install SCIP solver for cardinality constraints

Source: https://skfolio.org/llms-full.txt

Required for mixed-integer optimization when using cardinality constraints.

```bash
pip install cvxpy[SCIP]
```

--------------------------------

### RegimeAdjustedEWCovariance Usage Examples

Source: https://skfolio.org/_modules/skfolio/moments/covariance/_regime_adjusted_ew_covariance.html

Demonstrates initializing and fitting the RegimeAdjustedEWCovariance estimator with different targets, methods, and HAC correction settings.

```python
>>> from skfolio.datasets import load_sp500_dataset
>>> from skfolio.moments import RegimeAdjustedEWCovariance, RegimeAdjustmentTarget, RegimeAdjustmentMethod
>>> from skfolio.preprocessing import prices_to_returns
>>> import numpy as np
>>>
>>> prices = load_sp500_dataset()
>>> X = prices_to_returns(prices)
>>>
>>> # Portfolio target with inverse-vol weights and FIRST_MOMENT method (default)
>>> model = RegimeAdjustedEWCovariance(half_life=23)
>>> model.fit(X)
>>> print(model.regime_multiplier_)
>>>
>>> # DIAGONAL target (individual asset volatilities)
>>> model2 = RegimeAdjustedEWCovariance(
...     regime_target=RegimeAdjustmentTarget.DIAGONAL,
...     regime_method=RegimeAdjustmentMethod.RMS,
... )
>>> model2.fit(X)
>>>
>>> # Mahalanobis target (full covariance structure)
>>> model_maha = RegimeAdjustedEWCovariance(
...     regime_target=RegimeAdjustmentTarget.MAHALANOBIS,
...     regime_method=RegimeAdjustmentMethod.FIRST_MOMENT,
... )
>>> model_maha.fit(X)
>>>
>>> # Portfolio target with equal weights
>>> n_assets = X.shape[1]
>>> model_equal = RegimeAdjustedEWCovariance(
...     regime_target=RegimeAdjustmentTarget.PORTFOLIO,
...     regime_portfolio_weights=np.ones(n_assets) / n_assets,
... )
>>> model_equal.fit(X)
>>>
>>> # With Newey-West HAC correction
>>> model_hac = RegimeAdjustedEWCovariance(
...     half_life=23,
...     hac_lags=5
... )
>>> model_hac.fit(X)
```

--------------------------------

### Initialize and fit a CharacteristicsFactorModel

Source: https://skfolio.org/_modules/skfolio/prior/_characteristics_factor_model.html

Demonstrates setting up market, industry, and style factors, configuring the model, and fitting it to synthetic characteristics.

```python
from skfolio.datasets import make_synthetic_characteristics
from skfolio.descriptor import (
    BookToPrice,
    EWMomentum,
    EWMarketBeta,
    ForwardEarningsToPrice,
    LogMarketCap,
)
from skfolio.factor_exposure import (
    DerivedFactor,
    FixedWeightedFactor,
    GlobalFactor,
    OneHotCategoricalFactors,
)
from skfolio.moments import EWMu, RegimeAdjustedEWCovariance
from skfolio.prior import CharacteristicsFactorModel, EmpiricalPrior

characteristics = make_synthetic_characteristics()

# Market and industry factors.
market_factor = GlobalFactor()
industry_factors = OneHotCategoricalFactors(
    category="industry",
    family="industry",
)

# Style factors built from descriptors.
beta_factor = FixedWeightedFactor(
    descriptors=[("market_beta", EWMarketBeta(half_life=63))],
    family="style",
    transform_by_group="industry",
)
momentum_factor = FixedWeightedFactor(
    descriptors=[("momentum", EWMomentum(half_life=126, skip=21))],
    family="style",
    transform_by_group="industry",
)
size_factor = FixedWeightedFactor(
    descriptors=[("log_market_cap", LogMarketCap())],
    family="style",
    transform_by_group="industry",
)
earnings_yield_factor = FixedWeightedFactor(
    descriptors=[
        ("book_to_price", BookToPrice()),
        ("forward_earnings_to_price", ForwardEarningsToPrice()),
    ],
    weights=[0.5, 0.5],
    family="style",
    transform_by_group="industry",
)

# Style exposure derived from an existing factor.
non_linear_size_factor = DerivedFactor(
    source="size",
    func=lambda x: x**3,
    transform_by_group="industry",
)

model = CharacteristicsFactorModel(
    factors=[
        ("market", market_factor),
        ("industry", industry_factors),
        ("beta", beta_factor),
        ("momentum", momentum_factor),
        ("size", size_factor),
        ("earnings_yield", earnings_yield_factor),
        ("non_linear_size", non_linear_size_factor),
    ],
    neutralize_against={
        "momentum": ["industry"],
        "non_linear_size": ["size"],
    },
    constrained_families=[("industry", None)],
    factor_prior_estimator=EmpiricalPrior(
        mu_estimator=EWMu(),
        covariance_estimator=RegimeAdjustedEWCovariance(
            half_life=40,
            corr_half_life=60,
        ),
    ),
    inv_idio_variance_weight_shrinkage=0.5,
    n_jobs=-1,
)
model.fit(characteristics=characteristics)

# Inspect the fitted factor model and diagnostics.
fm = model.factor_model_
fm.summary()
fm.idio_calibration_summary()
fm.idio_vol_ic
fm.idio_tail_rate()
fm.factor_returns_df
fm.exposures_df
```

--------------------------------

### Install skfolio via pip

Source: https://skfolio.org/user_guide/install.html

Standard installation command for environments using pip.

```console
$ pip install skfolio
```

--------------------------------

### Mean-Risk Portfolio Optimization Examples

Source: https://skfolio.org/_modules/skfolio/optimization/convex/_mean_risk.html

Demonstrates common portfolio optimization tasks including minimum variance, maximum Sharpe ratio, constrained CVaR optimization, and efficient frontier calculation.

```python
>>> from skfolio import RiskMeasure
>>> from skfolio.datasets import load_sp500_dataset
>>> from skfolio.optimization import MeanRisk, ObjectiveFunction
>>> from skfolio.preprocessing import prices_to_returns
>>>
>>> # Load historical prices and convert them to returns
>>> prices = load_sp500_dataset()
>>> X = prices_to_returns(prices)
>>>
>>> # Minimum variance optimization
>>> model = MeanRisk(risk_measure=RiskMeasure.VARIANCE)
>>> model.fit(X)
>>> print(model.weights_)
>>>
>>> # Maximum Sharpe Ratio optimization
>>> model = MeanRisk(
...     objective_function=ObjectiveFunction.MAXIMIZE_RATIO,
...     risk_measure=RiskMeasure.STANDARD_DEVIATION,
... )
>>> model.fit(X)
>>> print(model.weights_)
>>>
>>> # Minimum CVaR optimization with weight and linear constraints
>>> model = MeanRisk(
...     risk_measure=RiskMeasure.CVAR,
...     max_weights=0.20,
...     linear_constraints=["AMD <= 0.10", "BAC + JPM >= 0.15"],
... )
>>> model.fit(X)
>>> print(model.weights_)
>>>
>>> # Compute portfolios along the mean-variance efficient frontier
>>> model = MeanRisk(
...     risk_measure=RiskMeasure.VARIANCE,
...     efficient_frontier_size=10,
... )
>>> model.fit(X)
>>> print(model.weights_.shape)
>>> population = model.predict(X)
```

--------------------------------

### Install skfolio via conda

Source: https://skfolio.org/user_guide/install.html

Installation command for environments using conda with the conda-forge channel.

```console
$ conda install -c conda-forge skfolio
```

--------------------------------

### Initialization Method

Source: https://skfolio.org/_modules/skfolio/moments/variance/_regime_adjusted_ew_variance.html

Sets up internal state variables, decay factors, and buffers required for variance estimation.

```python
    def _initialize(self):
        n_assets = self.n_features_in_
        self._decay = half_life_to_decay_factor(self.half_life)
        self._var = np.zeros(n_assets)
        self._is_active = np.ones(n_assets, dtype=bool)
        self._obs_count = np.zeros(n_assets, dtype=int)
        self._kappa = scs.digamma(0.5) + np.log(2.0)
        self._expected_abs_z = np.sqrt(2.0 / np.pi)
        self._regime_state = None
        self._n_regime_observations = 0

        if self.assume_centered:
            self.location_ = np.zeros(n_assets)
        else:
            self.location_ = np.full(n_assets, np.nan)

        if self.regime_half_life is None:
            self._regime_half_life = 0.5 * self.half_life
        else:
            self._regime_half_life = self.regime_half_life
        self._regime_decay = half_life_to_decay_factor(self._regime_half_life)

        if self.regime_min_observations is None:
            self._regime_min_observations = max(1, int(self._regime_half_life))
        else:
            self._regime_min_observations = self.regime_min_observations

        if self.hac_lags is not None:
            self._return_buffer = deque(maxlen=self.hac_lags)
        else:
            self._return_buffer = None
```

--------------------------------

### Configure Optimization with Fallback

Source: https://skfolio.org/_downloads/ee1b703d250baccfd19f66b808ca8cd0/plot_17_failure_and_fallbacks.ipynb

Demonstrates setting up a MeanRisk model with an intentionally infeasible constraint and a feasible fallback estimator.

```python
model = MeanRisk(
    min_weights=0.1,  # intentionally infeasible
    fallback=MeanRisk(min_weights=0.02),  # feasible fallback
)
model.fit(X_train)
print(model.weights_)
```

--------------------------------

### summary

Source: https://skfolio.org/generated/skfolio.population.Population.html

Get a summary of the portfolios in the population.

```APIDOC
## summary(formatted=True)

### Description
Summary of the portfolios in the population.

### Parameters
- **formatted** - If this is set to True, the measures are formatted into rounded string with units.

### Returns
- **summary** - The population’s portfolios summary.
```

--------------------------------

### composition

Source: https://skfolio.org/generated/skfolio.population.Population.html

Get the composition of each portfolio in the population.

```APIDOC
## composition(display_sub_ptf_name=True)

### Description
Returns the composition of each portfolio in the population.

### Parameters
- **display_sub_ptf_name** (bool, optional) - Optional - If set to True, each sub-portfolio name composing a multi-period portfolio is displayed.

### Returns
- **df** (DataFrame) - Composition of the portfolios in the population.
```

--------------------------------

### get_metadata_routing()

Source: https://skfolio.org/generated/skfolio.model_selection.OnlineGridSearch.html

Get metadata routing of this object.

```APIDOC
## get_metadata_routing()

### Description
Get metadata routing of this object.

### Returns
- **routing** - A MetadataRequest encapsulating routing information.
```

--------------------------------

### Optimization Output

Source: https://skfolio.org/llms-full.txt

Example output from the optimization process.

```none
Long positions: 178
Short positions: 180
Gross exposure: 2.00
```

--------------------------------

### returns_df

Source: https://skfolio.org/generated/skfolio.population.Population.html

Get a DataFrame of returns for each portfolio in the population.

```APIDOC
## returns_df(use_tag_in_column_name=True)

### Description
DataFrame of returns for each portfolio in the population.

### Parameters
- **use_tag_in_column_name** - Whether to include the portfolio tag in the DataFrame column names.

### Returns
- **returns** - Returns DataFrame where each column represents a portfolio’s returns time series.
```

--------------------------------

### EntropyPooling.__init__

Source: https://skfolio.org/_modules/skfolio/prior/_entropy_pooling.html

Initializes the EntropyPooling estimator with specific market views and solver configurations.

```APIDOC
## EntropyPooling.__init__

### Description
Initializes the EntropyPooling object to perform entropy pooling, which adjusts a prior distribution to satisfy a set of constraints (views).

### Parameters
- **prior_estimator** (BasePrior | None) - Optional - Estimator to use for the prior distribution.
- **mean_views** (list[str] | None) - Optional - List of mean constraints.
- **variance_views** (list[str] | None) - Optional - List of variance constraints.
- **correlation_views** (list[str] | None) - Optional - List of correlation constraints.
- **skew_views** (list[str] | None) - Optional - List of skewness constraints.
- **kurtosis_views** (list[str] | None) - Optional - List of kurtosis constraints.
- **value_at_risk_views** (list[str] | None) - Optional - List of VaR constraints.
- **cvar_views** (list[str] | None) - Optional - List of CVaR constraints.
- **value_at_risk_beta** (float) - Optional - Confidence level for VaR views (default 0.95).
- **cvar_beta** (float) - Optional - Confidence level for CVaR views (default 0.95).
- **groups** (skt.Groups | None) - Optional - Grouping of assets for views.
- **solver** (str) - Optional - Optimization solver to use (default 'TNC').
- **solver_params** (dict | None) - Optional - Additional parameters for the solver.
```

--------------------------------

### Get Metadata Routing

Source: https://skfolio.org/_modules/skfolio/prior/_characteristics_factor_model.html

Retrieves metadata routing for the estimator.

```python
def get_metadata_routing(self) -> skm.MetadataRouter:
    """Get metadata routing for this estimator.
```

--------------------------------

### Initialize and use EWVolatility

Source: https://skfolio.org/_modules/skfolio/descriptor/_volatility/_ew_volatility.html

Demonstrates how to import, instantiate, and apply the EWVolatility descriptor to synthetic asset characteristics.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import EWVolatility
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = EWVolatility()
>>> volatility = descriptor.fit_transform(X)
```

--------------------------------

### Get Metadata Routing

Source: https://skfolio.org/_modules/skfolio/prior/_opinion_pooling.html

Configures metadata routing for the sub-estimators.

```python
    def get_metadata_routing(self):
        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
```

--------------------------------

### Get estimator parameters

Source: https://skfolio.org/_modules/skfolio/optimization/ensemble/_stacking.html

Retrieves parameters for the ensemble and its sub-estimators.

```python
def get_params(self, deep=True):
    """Get the parameters of an estimator from the ensemble.

    Returns the parameters given in the constructor as well as the
    estimators contained within the `estimators` parameter.

    Parameters
    ----------
    deep : bool, default=True
        Setting it to True gets the various estimators and the parameters
        of the estimators as well.

    Returns
    -------
    params : dict
        Parameter and estimator names mapped to their values or parameter
        names mapped to their values.
    """
    return super()._get_params("estimators", deep=deep)
```

--------------------------------

### Initialize and manage an AssetPanel

Source: https://skfolio.org/user_guide/factor_models.html

Demonstrates how to construct an AssetPanel from aligned arrays, add categorical fields, inspect panel metadata, and perform I/O operations.

```python
import numpy as np
from skfolio.containers import AssetPanel
from skfolio.datasets import make_synthetic_characteristics

# Build a panel from aligned date-by-asset arrays.
panel = AssetPanel(
    fields={
        "returns": returns,        # ndarray (n_observations, n_assets)
        "market_cap": market_cap,  # ndarray (n_observations, n_assets)
    },
    observations=dates,
    asset_names=assets,
    active_mask=active_mask,
    estimation_mask=estimation_mask,
)
panel.add_categorical_field(
    name="industry",
    values=industry_codes,  # integer codes (n_observations, n_assets)
    levels=["energy", "bank", "technology"],
)

# Inspect dimensions, fields, missing values and mask coverage.
panel.info()

# Save and reload a panel.
panel.save("path/to/saved_panel")
saved_panel = AssetPanel.load("path/to/saved_panel")

# Generate a synthetic panel for examples and tests.
characteristics = make_synthetic_characteristics()
```

--------------------------------

### Get metadata routing

Source: https://skfolio.org/_modules/skfolio/optimization/ensemble/_stacking.html

Configures and returns a MetadataRouter for the ensemble estimators.

```python
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
```

--------------------------------

### Configure and Fit Benchmark Model

Source: https://skfolio.org/_downloads/d1e52834b5641a28615305f52497983e/plot_11_empirical_prior.ipynb

Creates a baseline Maximum Sharpe Ratio model using default moment estimators for comparison.

```python
bench = MeanRisk(
    risk_measure=RiskMeasure.VARIANCE,
    objective_function=ObjectiveFunction.MAXIMIZE_RATIO,
    portfolio_params=dict(name="Max Sharpe"),
)
bench.fit(X_train)
bench.weights_
```

--------------------------------

### Initialize Descriptors and Weights

Source: https://skfolio.org/_modules/skfolio/factor_exposure/_fixed_weighted_factor.html

Sets up descriptors, transformers, and validates descriptor weights during initialization.

```python
def _initialize(self):
        """Initialize descriptors, transformers and descriptor weights."""
        names, descriptors = self._validate_descriptors()

        self.descriptors_ = [sk.clone(des) for des in descriptors]
        self.named_descriptors_ = {
            name: estimator
            for name, estimator in zip(names, self.descriptors_, strict=True)
        }

        self.outlier_transformer_ = check_estimator(
            self.outlier_transformer,
            default=CSWinsorizer(),
            check_type=BaseCSTransformer,
        )

        self.scoring_transformer_ = check_estimator(
            self.scoring_transformer,
            default=CSStandardScaler(),
            check_type=BaseCSTransformer,
        )

        if self.weights is None:
            self.descriptor_weights_ = np.ones(len(descriptors)) / len(descriptors)
        else:
            self.descriptor_weights_ = np.asarray(self.weights)
            if self.descriptor_weights_.ndim != 1:
                raise ValueError("Descriptor weights should be a 1D array")
            if self.descriptor_weights_.size != len(descriptors):
                raise ValueError(
                    "Descriptor weights should have the same length of descriptors"
                )
            if np.any(self.descriptor_weights_ < 0):
                raise ValueError("Descriptor weights should be non-negative")
            if not np.isclose(self.descriptor_weights_.sum(), 1):
                raise ValueError("Descriptor weights should sum to 1")
```

--------------------------------

### fit(X, y=None)

Source: https://skfolio.org/generated/skfolio.pre_selection.SelectComplete.html

Run the SelectComplete transformer and get the appropriate assets.

```APIDOC
## fit(X, y=None)

### Description
Run the SelectComplete transformer and get the appropriate assets.

### Parameters
- **X** (array-like) - Required - Returns of the assets.
- **y** (None) - Optional - Not used, present for API consistency by convention.

### Returns
- **self** (object) - Fitted estimator.
```

--------------------------------

### Get Estimator Parameters

Source: https://skfolio.org/_modules/skfolio/prior/_characteristics_factor_model.html

Retrieves parameters for the estimator and its contained factor estimators.

```python
def get_params(self, deep: bool = True) -> dict[str, object]:
    """Get the parameters of this estimator.

    Returns the parameters given in the constructor as well as the
    factor estimators contained within the `factors` parameter.

    Parameters
    ----------
    deep : bool, default=True
        Setting it to True gets the various estimators and the parameters
        of the estimators as well.

    Returns
    -------
    params : dict
        Parameter and estimator names mapped to their values or parameter
        names mapped to their values.
    """
    return super()._get_params("factors", deep=deep)
```

--------------------------------

### Load Datasets and Prepare Returns

Source: https://skfolio.org/_downloads/e48165c5b00d9d5f038444a4e041dd91/plot_1_implied_volatility.ipynb

Imports necessary libraries and loads the S&P 500 price and implied volatility datasets, converting prices to returns.

```python
import numpy as np
import pandas as pd
import plotly.express as px
from plotly.io import show
from sklearn import set_config
from sklearn.model_selection import GridSearchCV, train_test_split

from skfolio import Population, RatioMeasure
from skfolio.datasets import load_sp500_dataset, load_sp500_implied_vol_dataset
from skfolio.metrics import make_scorer
from skfolio.model_selection import WalkForward, cross_val_predict
from skfolio.moments import (
    EmpiricalCovariance,
    GerberCovariance,
    ImpliedCovariance,
    LedoitWolf,
)
from skfolio.optimization import InverseVolatility, MeanRisk
from skfolio.preprocessing import prices_to_returns
from skfolio.prior import EmpiricalPrior

prices = load_sp500_dataset()
implied_vol = load_sp500_implied_vol_dataset()

X = prices_to_returns(prices)
X = X.loc["2010":]

implied_vol.head()
```

--------------------------------

### Compute Book-to-Price Ratio

Source: https://skfolio.org/_modules/skfolio/descriptor/_value/_book_to_price.html

Demonstrates how to initialize the BookToPrice descriptor and apply it to a synthetic asset panel.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import BookToPrice
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = BookToPrice()
>>> book_to_price = descriptor.fit_transform(X)
```

--------------------------------

### Initialize and Populate AssetPanel

Source: https://skfolio.org/_modules/skfolio/containers/_asset_panel/_panel.html

Demonstrates creating an AssetPanel instance with multiple fields and adding categorical and 3D fields.

```python
>>> import numpy as np
>>> from skfolio.containers import AssetPanel, concat
>>>
>>> n_observations = 252
>>> observations = np.arange(n_observations)
>>> assets = ["AAPL", "MSFT", "GOOG", "AMZN"]
>>> n_assets = len(assets)
>>>
>>> panel = AssetPanel(
...     fields={
...         "returns": np.random.randn(n_observations, n_assets),
...         "volume": np.random.lognormal(size=(n_observations, n_assets)),
...         "market_cap": np.random.lognormal(size=(n_observations, n_assets)),
...     },
...     observations=observations,
...     asset_names=assets,
... )
>>> panel.add_categorical_field(
...     name="industry",
...     values=np.random.randint(0, 3, size=(n_observations, n_assets)),
...     levels=["energy", "bank", "technology"],
... )
AssetPanel(n_observations=252, n_assets=4, n_fields=4)
>>> factor_labels = ["size", "momentum", "value"]
>>> panel.add_3d_field(
...     name="factor_exposure",
...     values=np.random.randn(n_observations, n_assets, len(factor_labels)),
...     third_axis_name="factor",
...     third_axis_labels=factor_labels,
...     third_axis_groups=["style", "style", "style"],
... )
AssetPanel(n_observations=252, n_assets=4, n_fields=5)
>>> panel.n_observations, panel.n_assets, panel.n_fields
(252, 4, 5)
```

--------------------------------

### Initialize NCO and Benchmark Models

Source: https://skfolio.org/auto_examples/clustering/plot_5_nco_grid_search.html

Instantiate the EqualWeighted benchmark and the NestedClustersOptimization model with default inner and clustering estimators.

```python
benchmark = EqualWeighted()

model_nco = NestedClustersOptimization(
    inner_estimator=MeanRisk(), clustering_estimator=HierarchicalClustering()
)
```

--------------------------------

### Notebook Metadata Configuration

Source: https://skfolio.org/_downloads/86bb6b38fa12c0a9056b77684af8076e/plot_8_regularization.ipynb

Defines the notebook format and versioning metadata for the regularization example.

```json
{
      "version": "3.13.15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
```

--------------------------------

### fit(X, y=None)

Source: https://skfolio.org/generated/skfolio.pre_selection.SelectNonDominated.html

Run the Non Dominated transformer and get the appropriate assets.

```APIDOC
## fit(X, y=None)

### Description
Run the Non Dominated transformer and get the appropriate assets.

### Parameters
- **X** (array-like) - Required - Price returns of the assets.
- **y** (None) - Optional - Not used, present for API consistency by convention.

### Returns
- **self** (estimator) - Fitted estimator.
```

--------------------------------

### Initialize Optimization Variables and Constraints

Source: https://skfolio.org/_modules/skfolio/optimization/convex/_mean_risk.html

Sets up the CVXPY variables and handles uncertainty sets and expected returns.

```python
        # Init weight variable and constraints
        w = cp.Variable(n_assets)
        constraints = []

        if self.objective_function == ObjectiveFunction.MAXIMIZE_RATIO:
            factor = cp.Variable()
        else:
            factor = cp.Constant(1)

        # Mu uncertainty set
        if self.mu_uncertainty_set_estimator_ is None:
            mu_uncertainty_set = cp.Constant(0)
        else:
            _call_estimator(
                self.mu_uncertainty_set_estimator_,
                method,
                X,
                y,
                routed_params=routed_params.mu_uncertainty_set_estimator,
                extra_params=_filter_supported_params(
                    self.mu_uncertainty_set_estimator_,
                    method,
                    return_distribution=return_distribution,
                ),
            )
            mu_uncertainty_set = self._cvx_mu_uncertainty_set(
                mu_uncertainty_set=self.mu_uncertainty_set_estimator_.uncertainty_set_,
                w=w,
            )

        # Expected returns
        expected_return = (
            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
        )

        # Regularization
        regularization = self._cvx_regularization(w=w)
```

--------------------------------

### Calculate Return on Equity

Source: https://skfolio.org/_modules/skfolio/descriptor/_profitability/_return_on_equity.html

Demonstrates how to initialize the ReturnOnEquity descriptor and apply it to a synthetic asset panel.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import ReturnOnEquity
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = ReturnOnEquity()
>>> return_on_equity = descriptor.fit_transform(X)
```

--------------------------------

### Get Fitted Copula Representation

Source: https://skfolio.org/_modules/skfolio/distribution/copula/_student_t.html

Returns a string representation of the fitted copula parameters.

```python
@property
def fitted_repr(self) -> str:
    """String representation of the fitted copula."""
    return f"{self.__class__.__name__}(rho={self.rho_:0.3f}, dof={self.dof_:0.2f})"
```

--------------------------------

### Calculate Sales-to-Price Ratio

Source: https://skfolio.org/_modules/skfolio/descriptor/_value/_sales_to_price.html

Demonstrates how to initialize the SalesToPrice descriptor and compute the ratio using synthetic asset characteristics.

```python
>>> from skfolio.datasets import make_synthetic_characteristics
>>> from skfolio.descriptor import SalesToPrice
>>>
>>> X = make_synthetic_characteristics()
>>>
>>> descriptor = SalesToPrice()
>>> sales_to_price = descriptor.fit_transform(X)
```

--------------------------------

### Display Solver Warnings

Source: https://skfolio.org/llms-full.txt

Example of warning output generated when optimization solutions may be inaccurate.

```none
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
/home/runner/work/skfolio/skfolio/src/skfolio/optimization/convex/_base.py:1234: UserWarning: Solution may be inaccurate. Try changing the solver params or the scale. For more details, set `solver_params=dict(verbose=True)`
  weights, problem_values = _solve(
```

--------------------------------

### Initialize Benchmark Model

Source: https://skfolio.org/_downloads/b8b5029e409a2addfdf3acb541fd3e11/plot_2_select_best_performers.ipynb

Creates a baseline Minimum Variance optimization model.

```python
benchmark = MeanRisk()
```

--------------------------------

### Initialize and fit an EmpiricalMuUncertaintySet

Source: https://skfolio.org/user_guide/uncertainty_set.html

Demonstrates the basic workflow for loading data, calculating returns, and fitting an empirical uncertainty set for expected returns.

```python
from skfolio.datasets import load_sp500_dataset
from skfolio.preprocessing import prices_to_returns
from skfolio.uncertainty_set import EmpiricalMuUncertaintySet

prices = load_sp500_dataset()
X = prices_to_returns(prices)

model = EmpiricalMuUncertaintySet()
model.fit(X)
print(model.uncertainty_set_)
```

--------------------------------

### Configure MeanRisk with uncertainty sets

Source: https://skfolio.org/user_guide/uncertainty_set.html

Demonstrates initializing a MeanRisk model with BootstrapMuUncertaintySet and EmpiricalCovarianceUncertaintySet estimators.

```python
from skfolio.datasets import load_sp500_dataset
from skfolio.optimization import MeanRisk, ObjectiveFunction
from skfolio.preprocessing import prices_to_returns
from skfolio.uncertainty_set import (
    BootstrapMuUncertaintySet,
    EmpiricalCovarianceUncertaintySet,
)

prices = load_sp500_dataset()
prices = prices["2020":]
X = prices_to_returns(prices)

model = MeanRisk(
    objective_function=ObjectiveFunction.MAXIMIZE_RATIO,
    mu_uncertainty_set_estimator=BootstrapMuUncertaintySet(confidence_level=0.5),
    covariance_uncertainty_set_estimator=EmpiricalCovarianceUncertaintySet(
        confidence_level=0.5
    ),
)
model.fit(X)
print(model.weights_)
```

--------------------------------

### Get Number of Splits

Source: https://skfolio.org/_modules/skfolio/model_selection/_multiple_randomized_cv.html

Calculates the total number of splits based on subsamples and walk-forward configuration.

```python
if X is None:
    raise ValueError("The 'X' parameter should not be None.")
X, y = sku.indexable(X, y)
if self.window_size is not None:
    X, _ = safe_split(X, indices=np.arange(self.window_size), axis=0)
return self.n_subsamples * self.walk_forward.get_n_splits(X)
```
Tokens:
Raw