Riskfolio-Lib Documentation

Riskfolio-Lib is a Python library for portfolio optimization built on top of CVXPY and integrated with Pandas. It allows users to build investment portfolios using mathematically complex models with minimal effort.

Key capabilities include:

• Mean Risk and Logarithmic Mean Risk (Kelly Criterion) Optimization: Supports 4 objective functions (Minimum Risk, Maximum Return, Maximum Utility, and Maximum Risk Adjusted Return Ratio) across 26 convex risk measures (Dispersion, Downside, and Drawdown).
• Risk Parity Optimization: Supports 22 convex risk measures.
• Hierarchical Clustering Optimization: Includes Hierarchical Risk Parity (HRP) and Hierarchical Equal Risk Contribution (HERC) using 37 risk measures.
• Nested Clustered Optimization (NCO): Uses four objective functions and various risk measures.
• Advanced Models: Supports Black Litterman, Risk Factors, Entropy Pooling, MVSK (Semidefinite Relaxation), and more.
• Constraints: Supports tracking error, turnover, cardinality (assets/categories), mutually exclusive/join investments, and graph-based constraints.
• Analysis Tools: Tools for calculating risk measures, risk contributions (per asset and per factor), uncertainty sets, asset clusters, and visualizing portfolio properties. Reports can be generated for Jupyter Notebook and Excel.

The ParamsEstimation module provides functions to estimate key portfolio parameters, including the vector of means, covariance matrix, and cokurtosis square matrix. Supported estimation methods include:

• Historical Estimates: Standard historical calculations.
• EWMA: Exponentially Weighted Moving Averages.
• Robust Covariance Estimators: Ledoit and Wolf, Oracle, Shrinkage, Graphical Lasso, j-LoGo, Gerber statistic, and Denoise estimators.
• Factor Models: Estimation of means, covariance, coskewness tensors, and cokurtosis matrices.
• Black Litterman Models:
  • Standard Black Litterman (incorporating analyst views on asset returns).
  • Augmented Black Litterman (incorporating views on risk factors).
  • Black Litterman Bayesian (incorporating views on risk factors).
• Entropy Pooling: Incorporating analyst views on asset returns to estimate means, covariance, coskewness, and cokurtosis.
• Bootstrapping: Estimating input parameters for uncertainty sets used in worst-case optimization models.

The course provides a comprehensive curriculum for mastering portfolio optimization using Python. Key modules include:

1. Scientific Computation Review: Numpy (Linear Algebra), Pandas (Dataframes), Scipy (Statistical/Linear Algebra), Montecarlo/Quasimontecarlo Simulation, and Statsmodels (Econometrics).
2. Convex Optimization: Covers CVXPY (DCP), Linear Programming (GMD, MAD, CVaR, CDaR, etc.), Quadratic Programming (Variance, Tracking Error), Second Order Cone Programming (Standard Deviation, VaR), Semidefinite Programming (Kurtosis, Skewness), Exponential Cone Programming (EVaR, EDaR), and Power Cone Programming (RLVaR, RLDaR).
3. Integer Programming: Quantile Optimization (VaR, Drawdown at Risk) and Integer Constraints (Cardinality, Join Investment, Mutually Exclusive, Buy in Threshold).
4. Machine Learning: Hierarchical Risk Parity (HRP), Hierarchical Equal Risk Contribution (HERC), and Nested Clustered Optimization.
5. Graph Theory: Centrality Measures, Network Constraints, and Cluster Constraints.
6. Parameter Estimation: Risk Factor Models (Explicit/Implicit), Black Litterman Models (Original, Augmented, Bayesian), and Entropy Pooling.
7. Backtesting: Walk Forward Method (Rolling/Expanding) and Cross-Validation (including Combinatorial Purged Cross-Validation).

To use Spectra, follow two main steps:

1. Define a matrix operation class: This class must implement the required operations, such as matrix-vector multiplication ($y=Ax$) or shift-solve ($y=(A-\sigma I)^{-\text{inv}})x$. You can use Spectra's helper classes (e.g., Spectra::DenseSymMatProd, Spectra::SparseGenMatProd) or implement your own class. If implementing your own, you must provide a using Scalar = ... typedef, rows(), cols(), and a perform_op method.

2. Create and run a solver object: Instantiate a solver class (e.g., Spectra::SymEigsSolver for symmetric matrices) with your operation object, the number of eigenvalues requested ($k$), and the subspace dimension. Call .init(), then .compute(SortRule), and finally retrieve results using .eigenvalues() or .eigenvectors() after checking .info() == CompInfo::Successful.

#include <Eigen/Core>
#include <Spectra/SymEigsSolver.h>
#include <iostream>

using namespace Spectra;

int main()
{
    // We are going to calculate the eigenvalues of M
    Eigen::MatrixXd A = Eigen::MatrixXd::Random(10, 10);
    Eigen::MatrixXd M = A + A.transpose();

    // Construct matrix operation object using the wrapper class DenseSymMatProd
    DenseSymMatProd<double> op(M);

    // Construct eigen solver object, requesting the largest three eigenvalues
    SymEigsSolver<DenseSymMatProd<double>> eigs(op, 3, 6);

    // Initialize and compute
    eigs.init();
    int nconv = eigs.compute(SortRule::LargestAlge);

    // Retrieve results
    Eigen::VectorXd evalues;
    if(eigs.info() == CompInfo::Successful)
        evalues = eigs.eigenvalues();

    std::cout << "Eigenvalues found:\n" << evalues << std::endl;

    return 0;
}