base module ¶

Base functions and classes for portfolio optimization.

prepare_returns function ¶

prepare_returns(
    returns,
    nan_to_zero=True,
    dropna_rows=True,
    dropna_cols=True,
    dropna_any=True
)

Prepare returns.

pypfopt_optimize function ¶

pypfopt_optimize(
    target=None,
    target_is_convex=None,
    weights_sum_to_one=None,
    target_constraints=None,
    target_solver=None,
    target_initial_guess=None,
    objectives=None,
    constraints=None,
    sector_mapper=None,
    sector_lower=None,
    sector_upper=None,
    discrete_allocation=None,
    allocation_method=None,
    silence_warnings=None,
    ignore_opt_errors=None,
    ignore_errors=None,
    **kwargs
)

Get allocation using PyPortfolioOpt.

First, it resolves the optimizer using resolve_pypfopt_optimizer(). Depending upon which arguments it takes, it may further resolve expected returns, covariance matrix, etc. Then, it adds objectives and constraints to the optimizer instance, calls the target metric, extracts the weights, and finally, converts the weights to an integer allocation (if requested).

To specify the optimizer, use optimizer (see resolve_pypfopt_optimizer()). To specify the expected returns, use expected_returns (see resolve_pypfopt_expected_returns()). To specify the covariance matrix, use cov_matrix (see resolve_pypfopt_cov_matrix()). All other keyword arguments in **kwargs are used by resolve_pypfopt_func_call().

Each objective can be a function, an attribute of pypfopt.objective_functions, or an iterable of such.

Each constraint can be a function or an interable of such.

The target can be an attribute of the optimizer, or a stand-alone function. If target_is_convex is True, the function is added as a convex function. Otherwise, the function is added as a non-convex function. The keyword arguments weights_sum_to_one and those starting with target are passed pypfopt.base_optimizer.BaseConvexOptimizer.convex_objective and pypfopt.base_optimizer.BaseConvexOptimizer.nonconvex_objective respectively.

Set ignore_opt_errors to True to ignore any target optimization errors. Set ignore_errors to True to ignore any errors, even those caused by the user.

If discrete_allocation is True, resolves pypfopt.discrete_allocation.DiscreteAllocation and calls allocation_method as an attribute of the allocation object.

Any function is resolved using resolve_pypfopt_func_call().

For defaults, see pypfopt under pfopt.

Usage

Using mean historical returns, Ledoit-Wolf covariance matrix with constant variance, and efficient frontier:

>>> from vectorbtpro import *

>>> data = vbt.YFData.pull(["MSFT", "AMZN", "KO", "MA"])

100%

>>> vbt.pypfopt_optimize(prices=data.get("Close"))
{'MSFT': 0.13324, 'AMZN': 0.10016, 'KO': 0.03229, 'MA': 0.73431}

EMA historical returns and sample covariance:

>>> vbt.pypfopt_optimize(
...     prices=data.get("Close"),
...     expected_returns="ema_historical_return",
...     cov_matrix="sample_cov"
... )
{'MSFT': 0.08984, 'AMZN': 0.0, 'KO': 0.91016, 'MA': 0.0}

EMA historical returns, efficient Conditional Value at Risk, and other parameters automatically passed to their respective functions. Optimized towards lowest CVaR:

>>> vbt.pypfopt_optimize(
...     prices=data.get("Close"),
...     expected_returns="ema_historical_return",
...     optimizer="efficient_cvar",
...     beta=0.9,
...     weight_bounds=(-1, 1),
...     target="min_cvar"
... )
{'MSFT': 0.14779, 'AMZN': 0.07224, 'KO': 0.77552, 'MA': 0.00445}

Adding custom objectives:

>>> vbt.pypfopt_optimize(
...     prices=data.get("Close"),
...     objectives=["L2_reg"],
...     gamma=0.1,
...     target="min_volatility"
... )
{'MSFT': 0.22228, 'AMZN': 0.15685, 'KO': 0.28712, 'MA': 0.33375}

Adding custom constraints:

>>> vbt.pypfopt_optimize(
...     prices=data.get("Close"),
...     constraints=[lambda w: w[data.symbols.index("MSFT")] <= 0.1]
... )
{'MSFT': 0.1, 'AMZN': 0.10676, 'KO': 0.04341, 'MA': 0.74982}

Optimizing towards a custom convex objective (to add a non-convex objective, set target_is_convex to False):

>>> import cvxpy as cp

>>> def logarithmic_barrier_objective(w, cov_matrix, k=0.1):
...     log_sum = cp.sum(cp.log(w))
...     var = cp.quad_form(w, cov_matrix)
...     return var - k * log_sum

>>> pypfopt_optimize(
...     prices=data.get("Close"),
...     target=logarithmic_barrier_objective
... )
{'MSFT': 0.24595, 'AMZN': 0.23047, 'KO': 0.25862, 'MA': 0.26496}

resolve_asset_classes function ¶

resolve_asset_classes(
    asset_classes,
    columns,
    col_indices=None
)

Resolve asset classes for Riskfolio-Lib.

Supports the following formats:

None: Takes columns where the bottom-most level is assumed to be assets
Index: Each level in the index must be a different asset class set
Nested dict: Each sub-dict must be a different asset class set
Sequence of strings or ints: Matches them against level names in the columns. If the columns have a single level, or some level names were not found, uses the sequence directly as one class asset set named 'Class'.
Sequence of dicts: Each dict becomes a row in the new DataFrame
DataFrame where the first column is the asset list and the next columns are the different asset’s classes sets (this is the target format accepted by Riskfolio-Lib). See an example here.

Note

If asset_classes is neither None nor a DataFrame, the bottom-most level in columns gets renamed to 'Assets' and becomes the first column of the new DataFrame.