Python Code for Portfolio Optimization Chapter 10 – Portfolios with Alternative Risk Measures
Daniel P. Palomar (2025). Portfolio Optimization: Theory and Application. Cambridge University Press.
Last update: March 29, 2025
Contributors:
Libraries¶
The following libraries are used in the examples:
# Core numerical computing
import numpy as np
import pandas as pd
from typing import Dict, Tuple, List, Callable
import warnings
warnings.filterwarnings('ignore')
import time
# For financial data
import yfinance as yf # Loading financial data
import empyrical as emp # Performance metrics
# Book data (pip install "git+https://github.com/dppalomar/pob.git#subdirectory=python")
from pob_python import SP500_stocks_2015to2020, SP500_index_2015to2020
# Plotting
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import seaborn as sns
sns.set_theme(style="darkgrid")
# Optimization
import cvxpy as cp # interface for convex optimization solvers
Some math definitions for the equations:
$\def\bm#1{\boldsymbol{#1}}$ $\def\textm#1{\textsf{#1}}$ $\def\T{{\mkern-2mu\raise-1mu\mathsf{T}}}}$ $\def\R{\mathbb{R}}$ $\def\E{{\rm I\kern-.2em E}}$ $\def\w{\bm{w}}$ $\def\bmu{\bm{\mu}}}$ $\def\bSigma{\bm{\Sigma}}}$
Warm-up - Markowitz's portfolio¶
Markowitz's mean-variance portfolio (MVP) with no shorting is formulated as $$ \begin{array}{ll} \underset{\mathbf{w}}{\textsf{maximize}} & \boldsymbol{\mu}^\T\w -\lambda\w^\T\mathbf{\Sigma}\w\\ {\textsf{subject to}} & \mathbf{1}^T\w = 1\\ & \w\ge\mathbf{0}. \end{array} $$
For completeness, we can also consider the Global Minimum Variance Portfolio (GMVP), which doesn't make use of $\boldsymbol{\mu}$: $$\begin{array}{ll} \underset{\w}{\textsf{minimize}} & \w^\T\mathbf{\Sigma}\w\\ {\textsf{subject to}} & \mathbf{1}^\T\w = 1\\ & \w\ge\mathbf{0}. \end{array}$$
Since a closed-form solution does not exist with the constraint $\w\ge\mathbf{0}$, we need to resort to a solver.
We can conveniently use the library cvxpy (although the computational cost will be high and the solution not totally robust,
if necessary use a QP solver like quadprog):
#
# Define portfolios
#
def design_GMVP(Sigma: np.ndarray) -> np.ndarray:
N = len(Sigma)
w = cp.Variable(N)
prob = cp.Problem(cp.Minimize(cp.quad_form(w, Sigma)),
[cp.sum(w) == 1, w >= 0])
prob.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
def design_MVP(mu: np.ndarray, Sigma: np.ndarray, lmd: float = 1) -> np.ndarray:
N = len(Sigma)
w = cp.Variable(N)
prob = cp.Problem(cp.Maximize(mu @ w - (lmd/2) * cp.quad_form(w, Sigma)),
[cp.sum(w) == 1, w >= 0])
prob.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
# Get data
stock_prices = SP500_stocks_2015to2020.loc["2020":"2020-09", ["AAPL", "NFLX", "TSCO", "MGM", "MSFT", "FB", "AMZN", "GOOGL"]]
# Compute returns
X_lin = stock_prices.pct_change().dropna()
X_log = np.log(stock_prices).diff().dropna()
# or: X_log = np.log(1 + X_lin)
# Split data into training and test
T, N = X_lin.shape
T_trn = round(0.70*T)
X_lin_trn = X_lin.iloc[:T_trn]
X_lin_tst = X_lin.iloc[T_trn:]
X_log_trn = X_log.iloc[:T_trn]
X_log_tst = X_log.iloc[T_trn:]
# Estimate mu and Sigma with training data
mu = X_log_trn.mean().values
Sigma = X_log_trn.cov().values
# Calculate portfolios from data
w_GMVP = design_GMVP(Sigma)
w_MVP = design_MVP(mu, Sigma, lmd=10)
# Put together all portfolios
portfolios_df = pd.DataFrame(np.column_stack([w_GMVP, w_MVP]), columns=["GMVP", "Markowitz"], index=stock_prices.columns)
We can now compare the allocations of the portfolios:
portfolios_df
| GMVP | Markowitz | |
|---|---|---|
| AAPL | 0.000000 | 0.000000 |
| NFLX | 0.000000 | 0.000000 |
| TSCO | 0.325649 | 0.231824 |
| MGM | 0.000000 | 0.000000 |
| MSFT | 0.000000 | 0.000000 |
| FB | 0.000000 | 0.000000 |
| AMZN | 0.621097 | 0.768176 |
| GOOGL | 0.053254 | 0.000000 |
fig, ax = plt.subplots(figsize=(12, 4))
portfolios_df.plot.bar(rot=0, width=0.5, title="Portfolio allocation", ax=ax)
<Axes: title={'center': 'Portfolio allocation'}>
Then we can assess the performance (in-sample vs out-of-sample):
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
def print_table_performance_metrics(rets: pd.DataFrame) -> None:
display(pd.DataFrame({
'Annualized Return': rets.apply(emp.annual_return).apply(lambda x: f"{x:.2%}"),
'Annualized Volatility': rets.apply(emp.annual_volatility).apply(lambda x: f"{x:.2%}"),
'Sharpe Ratio': rets.apply(emp.sharpe_ratio).apply(lambda x: f"{x:.3}"),
'Maximum Drawdown': rets.apply(emp.max_drawdown).apply(lambda x: f"{x:.3}")
}))
print("In-sample:")
print_table_performance_metrics(ret_all_trn)
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
In-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 135.80% | 37.78% | 2.46 | -0.256 |
| Markowitz | 149.18% | 38.21% | 2.58 | -0.243 |
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
We can see that the mean-variance Markowitz portfolio performs even worse than the GMVP in the out-of-sample (the in-sample Sharpe ratio is approximately the same though).
Let us plot the cumulative PnL for the training and test sets:
pnl_trn = emp.cum_returns(ret_all_trn)
fig, ax = plt.subplots(figsize=(12,6))
pnl_trn.plot(title="Cumulative PnL during training set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during training set'}, xlabel='Date'>
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
Downside risk portfolios¶
The Markowitz's porftolio, the variance $\w^\T\bSigma\w$ is a measure of risk, but is not a good measure of risk in practice since it penalizes both the unwanted high losses and the desired low losses (or gains).
Indeed, the mean-variance portfolio framework penalizes up-side and down-side risk equally, whereas most investors don't mind up-side risk.
To overcome the limitations of the variance as risk measure, a number of alternative risk measures have been proposed. We will now consider the Downside Risk (DR):
Let $R$ be a random variable representing the return. The lower partial moments (LPM) is defined as $$\textm{LPM} = \E \left[\left((\tau - R)^+\right)^\alpha\right],$$ where $(\cdot)^+=\max(0, \cdot)$ and we will use $\tau = \E\left[R\right]$ as disaster level. The parameter $\alpha$ allows different levels of risk-aversion:
- $\alpha=1$ suits a neutral investor: $$\E\left[(\tau - R)^+\right]$$
- $\alpha=2$ is more risk-averse and yields the semi-variance: $$\textsf{SV} = \E\left[\left((\tau - R)^+\right)^2\right]$$
- $\alpha=3$ is even more risk-averse: $$\E\left[\left((\tau - R)^+\right)^3\right]$$
Downside Risk portfolio:
We will use sample approximation of the downside risk: $$\begin{aligned} \E\left[\left((\E[R] - R)^+\right)^\alpha\right] & \approx \frac{1}{T}\sum_{t=1}^T\left(\left(\E[R] - R_t\right)^+\right)^\alpha\\ & \approx \frac{1}{T}\sum_{t=1}^T\left(\left(\frac{1}{T}\sum_{\tau=1}^TR_\tau - R_t\right)^+\right)^\alpha. \end{aligned}$$
The mean-downside risk portfolio formulation is the convex (assuming $\alpha \ge 1$) problem $$\begin{array}{ll} \underset{\mathbf{w}}{\textsf{maximize}} & \w^\T\bmu-\lambda \frac{1}{T}\sum_{t=1}^T\left(\left(\w^\T\bmu - \w^\T\mathbf{r}_t\right)^+\right)^\alpha\\ \textsf{subject to} & \mathbf{1}^\T\w = 1\\ & \w\ge\mathbf{0}. \end{array}$$
For $\alpha=1$, the problem is an LP: $$\begin{array}{ll} \underset{\mathbf{w}}{\textsf{maximize}} & \w^\T\boldsymbol{\mu}-\lambda \frac{1}{T}\sum_{t=1}^T\left(\w^\T\bmu - \w^\T\mathbf{r}_t\right)^+\\ \textsf{subject to} & \mathbf{1}^\T\w = 1\\ & \w\ge\mathbf{0}. \end{array}$$
For $\alpha=2$, the problem is the mean--semi-variance portfolio formulation which is a convex QP problem $$\begin{array}{ll} \underset{\w}{\textsf{maximize}} & \w^\T\bmu-\lambda \frac{1}{T}\sum_{t=1}^T\left(\left(\w^\T\bmu - \w^\T\mathbf{r}_t\right)^+\right)^2\\ \textsf{subject to} & \mathbf{1}^\T\w = 1\\ & \w\ge\mathbf{0}. \end{array}$$
For $\alpha=3$, the problem is not an LP or QP, but still convex.
We can now compute the different portfolios $\w$ for different values of $\alpha$ with the cvxpy library
(see https://www.cvxpy.org/index.html for list of functions):
def design_portfolioDR(X: pd.DataFrame, lmd: float = 1, alpha: float = 2) -> np.ndarray:
T, N = X.shape
mu = X.mean().values
X_np = X.to_numpy()
# Design portfolio
w = cp.Variable(N)
problem = cp.Problem(cp.Maximize(w @ mu - (lmd/2)*cp.mean(cp.pos(w @ mu - X_np @ w) ** alpha)),
[w >= 0, cp.sum(w) == 1])
problem.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
w_DR_alpha1 = design_portfolioDR(X_log_trn, alpha=1, lmd=10)
w_DR_alpha2 = design_portfolioDR(X_log_trn, alpha=2, lmd=10)
w_DR_alpha3 = design_portfolioDR(X_log_trn, alpha=3, lmd=10)
# Put together all portfolios
portfolios_df["DR-alpha=1"] = w_DR_alpha1
portfolios_df["DR-alpha=2"] = w_DR_alpha2
portfolios_df["DR-alpha=3"] = w_DR_alpha3
portfolios_df
| GMVP | Markowitz | DR-alpha=1 | DR-alpha=2 | DR-alpha=3 | |
|---|---|---|---|---|---|
| AAPL | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| NFLX | 0.000000 | 0.000000 | 0.000001 | 0.000000 | 0.0 |
| TSCO | 0.325649 | 0.231824 | 0.483524 | 0.036066 | 0.0 |
| MGM | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| MSFT | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| FB | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| AMZN | 0.621097 | 0.768176 | 0.516475 | 0.963934 | 1.0 |
| GOOGL | 0.053254 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
# Plot allocation
fig, ax = plt.subplots(figsize=(12, 4))
portfolios_df.plot.bar(rot=0, width=0.5, title="Portfolio allocation", ax=ax)
<Axes: title={'center': 'Portfolio allocation'}>
Let compare the performance (in-sample vs out-of-sample):
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
print("In-sample:")
print_table_performance_metrics(ret_all_trn)
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
In-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 135.80% | 37.78% | 2.46 | -0.256 |
| Markowitz | 149.18% | 38.21% | 2.58 | -0.243 |
| DR-alpha=1 | 137.74% | 38.26% | 2.46 | -0.266 |
| DR-alpha=2 | 156.34% | 40.30% | 2.54 | -0.227 |
| DR-alpha=3 | 157.48% | 40.87% | 2.52 | -0.227 |
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
| DR-alpha=1 | 22.21% | 29.28% | 0.828 | -0.125 |
| DR-alpha=2 | 12.13% | 38.03% | 0.486 | -0.16 |
| DR-alpha=3 | 11.25% | 38.90% | 0.463 | -0.163 |
Let us plot the cumulative PnL for the training and test sets:
pnl_trn = emp.cum_returns(ret_all_trn)
fig, ax = plt.subplots(figsize=(12,6))
pnl_trn.plot(title="Cumulative PnL during training set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during training set'}, xlabel='Date'>
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
Let's keep the DR portfolio with $\alpha=1$:
# Drop the two worst DR portfolios
portfolios_df.drop(columns=["DR-alpha=2", "DR-alpha=3"], inplace=True)
Tail portfolios¶
The CVaR can be conveniently obtained as the minimum of an auxiliary convex function: $$\mathsf{CVaR}_{\alpha}\left(\w^{\T}\mathbf{r}\right)=\min_{\zeta}F_{\alpha}\left(\w,\zeta\right)$$ where $$F_{\alpha}(\w,\zeta)=\zeta+\frac{1}{1-\alpha}\E\left[-\w^{\T}\mathbf{r}-\zeta\right]^{+}.$$
We can use a sample average approximation of $F_{\alpha}(\w,\zeta)$: $$F_{\alpha}(\w,\zeta) \approx \zeta+\frac{1}{1-\alpha}\frac{1}{T}\sum_{t=1}^{T}\left[-\w^\T\mathbf{r}_t-\zeta\right]^{+}.$$ We define the dummy variables $z_t$: $$z_t\geq\left[-\w^\T\mathbf{r}_t-\zeta\right]^{+} \Longrightarrow z_t\geq -\w^\T\mathbf{r}_t-\zeta,\,z_t\geq0.$$
The mean-CVaR portfolio formulation can be finally written as the (convex) LP: $$ \begin{array}{ll} \underset{\w, \mathbf{z}, \zeta}{\textsf{maximize}} & \w^\T\bmu - \lambda\left(\zeta+\frac{1}{1-\alpha}\frac{1}{T}\sum_{t=1}^{T}z_{t}\right)\\ \textsf{subject to} & 0\leq z_{t}\geq-\w^{\T}\mathbf{r}_{t}-\zeta,\quad t=1,\dots,T\\ & \mathbf{1}^\T\w=1,\quad \w\ge\mathbf{0}. \end{array} $$
We are now ready to compute the mean-CVaR portfolio with the cvxpy library:
def design_portfolioCVaR(X: pd.DataFrame, lmd: float = 1, alpha=0.95) -> np.ndarray:
T, N = X.shape
mu = X.mean().values
X_np = X.to_numpy()
# Design portfolio
w = cp.Variable(N)
z = cp.Variable(T)
zeta = cp.Variable(1)
problem = cp.Problem(cp.Maximize(w @ mu - lmd * (zeta + 1 / (1 - alpha) * cp.mean(z))),
[z >= 0, z >= - X_np @ w - zeta, w >= 0, cp.sum(w) == 1])
problem.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
w_CVaR095 = design_portfolioCVaR(X_log_trn, alpha=0.95)
w_CVaR097 = design_portfolioCVaR(X_log_trn, alpha=0.97)
# Put together all portfolios
portfolios_df["CVaR-alpha=0.95"] = w_CVaR095
portfolios_df["CVaR-alpha=0.97"] = w_CVaR097
portfolios_df
| GMVP | Markowitz | DR-alpha=1 | CVaR-alpha=0.95 | CVaR-alpha=0.97 | |
|---|---|---|---|---|---|
| AAPL | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| NFLX | 0.000000 | 0.000000 | 0.000001 | 0.407594 | 0.0 |
| TSCO | 0.325649 | 0.231824 | 0.483524 | 0.000000 | 0.0 |
| MGM | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| MSFT | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| FB | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
| AMZN | 0.621097 | 0.768176 | 0.516475 | 0.592406 | 1.0 |
| GOOGL | 0.053254 | 0.000000 | 0.000000 | 0.000000 | 0.0 |
# Plot allocation
fig, ax = plt.subplots(figsize=(12, 4))
portfolios_df.plot.bar(rot=0, width=0.5, title="Portfolio allocation", ax=ax)
<Axes: title={'center': 'Portfolio allocation'}>
Let compare the performance (in-sample vs out-of-sample):
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
print("In-sample:")
print_table_performance_metrics(ret_all_trn)
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
In-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 135.80% | 37.78% | 2.46 | -0.256 |
| Markowitz | 149.18% | 38.21% | 2.58 | -0.243 |
| DR-alpha=1 | 137.74% | 38.26% | 2.46 | -0.266 |
| CVaR-alpha=0.95 | 145.86% | 41.30% | 2.39 | -0.223 |
| CVaR-alpha=0.97 | 157.48% | 40.87% | 2.52 | -0.227 |
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
| DR-alpha=1 | 22.21% | 29.28% | 0.828 | -0.125 |
| CVaR-alpha=0.95 | 7.65% | 37.29% | 0.38 | -0.157 |
| CVaR-alpha=0.97 | 11.25% | 38.90% | 0.463 | -0.163 |
pnl_trn = emp.cum_returns(ret_all_trn)
fig, ax = plt.subplots(figsize=(12,6))
pnl_trn.plot(title="Cumulative PnL during training set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during training set'}, xlabel='Date'>
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
Let's keep the CVaR portfolio with $\alpha=0.97$:
portfolios_df.drop(columns=["CVaR-alpha=0.95"], inplace=True)
Drawdown portfolios¶
Mean - Max-DD portfolio¶
We can formulate the maximization of the expected return subject to a Max-DD constraint as $$\begin{array}{ll} \underset{\w,s}{\textsf{maximize}} & \w^\T\bmu - \lambda s\\ \textsf{subject to} & \max_{1\le t\le T} \{\max_{1\le\tau\le t}\w^\T\mathbf{r}_{\tau}^{\sf cum} - \w^\T\mathbf{r}_t^{\sf cum}\} \le s\\ & \mathbf{1}^\T\w=1,\quad \w\ge\mathbf{0}, \end{array}$$ which can be more conveniently rewritten as the following LP: $$ \begin{array}{ll} \underset{\w, \{u_t\},s}{\textsf{maximize}} & \w^\T\bmu - \lambda s\\ \textsf{subject to} & \w^\T\mathbf{r}_{t}^{\sf cum} \le u_t \le \w^\T\mathbf{r}_t^{\sf cum} + s, \quad\forall 1\le t\le T\\ & u_{t-1} \le u_t\\ & \mathbf{1}^\T\w=1,\quad \w\ge\mathbf{0}. \end{array} $$
def design_portfolioMaxDD(X: pd.DataFrame, lmd: float = 1) -> np.ndarray:
T, N = X.shape
mu = X.mean().values
X_cum = X.cumsum()
X_cum_np = X_cum.to_numpy()
# Design portfolio
w = cp.Variable(N)
u = cp.Variable(T)
s = cp.Variable(1)
problem = cp.Problem(cp.Maximize(w @ mu - lmd * s),
[w >= 0, cp.sum(w) == 1,
u <= X_cum_np @ w + s, u >= X_cum_np @ w,
u[1:] >= u[:-1]])
result = problem.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
w_MaxDD_lmd1e_3 = design_portfolioMaxDD(X_log_trn, lmd=1e-3)
w_MaxDD_lmd1e_1 = design_portfolioMaxDD(X_log_trn, lmd=1e-1)
# Put together all portfolios
portfolios_df["Max-DD-lmd=1e-3"] = w_MaxDD_lmd1e_3
portfolios_df["Max-DD-lmd=1e-1"] = w_MaxDD_lmd1e_1
portfolios_df
| GMVP | Markowitz | DR-alpha=1 | CVaR-alpha=0.97 | Max-DD-lmd=1e-3 | Max-DD-lmd=1e-1 | |
|---|---|---|---|---|---|---|
| AAPL | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.0 | 0.000000 |
| NFLX | 0.000000 | 0.000000 | 0.000001 | 0.0 | 0.0 | 0.122339 |
| TSCO | 0.325649 | 0.231824 | 0.483524 | 0.0 | 0.0 | 0.000000 |
| MGM | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.0 | 0.000000 |
| MSFT | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.0 | 0.000000 |
| FB | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.0 | 0.000000 |
| AMZN | 0.621097 | 0.768176 | 0.516475 | 1.0 | 1.0 | 0.877661 |
| GOOGL | 0.053254 | 0.000000 | 0.000000 | 0.0 | 0.0 | 0.000000 |
# Plot allocation
fig, ax = plt.subplots(figsize=(12, 4))
portfolios_df.plot.bar(rot=0, width=0.5, title="Portfolio allocation", ax=ax)
<Axes: title={'center': 'Portfolio allocation'}>
Let compare the performance (in-sample vs out-of-sample):
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
print("In-sample:")
print_table_performance_metrics(ret_all_trn)
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
In-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 135.80% | 37.78% | 2.46 | -0.256 |
| Markowitz | 149.18% | 38.21% | 2.58 | -0.243 |
| DR-alpha=1 | 137.74% | 38.26% | 2.46 | -0.266 |
| CVaR-alpha=0.97 | 157.48% | 40.87% | 2.52 | -0.227 |
| Max-DD-lmd=1e-3 | 157.48% | 40.87% | 2.52 | -0.227 |
| Max-DD-lmd=1e-1 | 154.41% | 40.54% | 2.51 | -0.222 |
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
| DR-alpha=1 | 22.21% | 29.28% | 0.828 | -0.125 |
| CVaR-alpha=0.97 | 11.25% | 38.90% | 0.463 | -0.163 |
| Max-DD-lmd=1e-3 | 11.25% | 38.90% | 0.463 | -0.163 |
| Max-DD-lmd=1e-1 | 10.48% | 37.59% | 0.448 | -0.161 |
We can see that the Max-DD designs indeed have a controlled maximum drawdown at least in-sample; however, out-of-sample it is not mantained. This is probably due to not having enough training samples. Also, the Sharpe ratio doesn't seem to be very good.
Let us plot the cumulative PnL for the training and test sets:
pnl_trn = emp.cum_returns(ret_all_trn)
fig, ax = plt.subplots(figsize=(12,6))
pnl_trn.plot(title="Cumulative PnL during training set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during training set'}, xlabel='Date'>
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
Let's keep the Max-DD portfolio with $\alpha=10^{-1}$:
portfolios_df.drop(columns=["Max-DD-lmd=1e-3"], inplace=True)
portfolios_df.columns
Index(['GMVP', 'Markowitz', 'DR-alpha=1', 'CVaR-alpha=0.97',
'Max-DD-lmd=1e-1'],
dtype='object')
Mean - Ave-DD portfolio¶
We can formulate the maximization of the expected return subject to an Ave-DD constraint as the following LP: $$ \begin{array}{ll} \underset{\w, \{u_t\}, s}{\textsf{maximize}} & \w^\T\bmu - \lambda s\\ \textsf{subject to} & \frac{1}{T}\sum_{t=1}^T u_t \le \sum_{t=1}^T\w^\T\mathbf{r}_t^{\sf cum} + s\\ & \w^\T\mathbf{r}_{t}^{\sf cum} \le u_t\\ & u_{t-1} \le u_t\\ & \mathbf{1}^\T\w=1,\quad \w\ge\mathbf{0}. \end{array} $$
def design_portfolioAveDD(X: pd.DataFrame, lmd: float = 1e-1) -> np.ndarray:
T, N = X.shape
mu = X.mean().values
X_cum = X.cumsum()
X_cum_np = X_cum.to_numpy()
# Design portfolio
w = cp.Variable(N)
u = cp.Variable(T)
s = cp.Variable(1)
problem = cp.Problem(cp.Maximize(w @ mu - lmd * s),
[w >= 0, cp.sum(w) == 1,
cp.mean(u) <= cp.mean(X_cum_np @ w) + s, u >= X_cum_np @ w,
u[1:] >= u[:-1]])
result = problem.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
w_AveDD_lmd1e_3 = design_portfolioAveDD(X_log_trn, lmd=1e-3)
w_AveDD_lmd1e_1 = design_portfolioAveDD(X_log_trn, lmd=1e-1)
# Put together all portfolios
portfolios_df["Ave-DD-lmd=1e-3"] = w_AveDD_lmd1e_3
portfolios_df["Ave-DD-lmd=1e-1"] = w_AveDD_lmd1e_1
portfolios_df
| GMVP | Markowitz | DR-alpha=1 | CVaR-alpha=0.97 | Max-DD-lmd=1e-1 | Ave-DD-lmd=1e-3 | Ave-DD-lmd=1e-1 | |
|---|---|---|---|---|---|---|---|
| AAPL | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| NFLX | 0.000000 | 0.000000 | 0.000001 | 0.0 | 0.122339 | 0.0 | 0.505511 |
| TSCO | 0.325649 | 0.231824 | 0.483524 | 0.0 | 0.000000 | 0.0 | 0.145774 |
| MGM | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| MSFT | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| FB | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| AMZN | 0.621097 | 0.768176 | 0.516475 | 1.0 | 0.877661 | 1.0 | 0.348714 |
| GOOGL | 0.053254 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
# Plot allocation
fig, ax = plt.subplots(figsize=(12, 4))
portfolios_df.plot.bar(rot=0, width=0.5, title="Portfolio allocation", ax=ax)
<Axes: title={'center': 'Portfolio allocation'}>
Let compare the performance (in-sample vs out-of-sample):
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
print("In-sample:")
print_table_performance_metrics(ret_all_trn)
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
In-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 135.80% | 37.78% | 2.46 | -0.256 |
| Markowitz | 149.18% | 38.21% | 2.58 | -0.243 |
| DR-alpha=1 | 137.74% | 38.26% | 2.46 | -0.266 |
| CVaR-alpha=0.97 | 157.48% | 40.87% | 2.52 | -0.227 |
| Max-DD-lmd=1e-1 | 154.41% | 40.54% | 2.51 | -0.222 |
| Ave-DD-lmd=1e-3 | 157.48% | 40.87% | 2.52 | -0.227 |
| Ave-DD-lmd=1e-1 | 136.96% | 41.04% | 2.31 | -0.237 |
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
| DR-alpha=1 | 22.21% | 29.28% | 0.828 | -0.125 |
| CVaR-alpha=0.97 | 11.25% | 38.90% | 0.463 | -0.163 |
| Max-DD-lmd=1e-1 | 10.48% | 37.59% | 0.448 | -0.161 |
| Ave-DD-lmd=1e-3 | 11.25% | 38.90% | 0.463 | -0.163 |
| Ave-DD-lmd=1e-1 | 9.37% | 35.52% | 0.426 | -0.144 |
The Ave-DD designs have a controlled average drawdown. But in terms of Sharpe ratio they are not especially outstanding.
Let us plot the cumulative PnL over time for the training and test sets:
pnl_trn = emp.cum_returns(ret_all_trn)
fig, ax = plt.subplots(figsize=(12,6))
pnl_trn.plot(title="Cumulative PnL during training set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during training set'}, xlabel='Date'>
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
Let's keep the Ave-DD portfolio with $\alpha=10^{-1}$:
portfolios_df.drop(columns=["Ave-DD-lmd=1e-3"], inplace=True)
portfolios_df.columns
Index(['GMVP', 'Markowitz', 'DR-alpha=1', 'CVaR-alpha=0.97', 'Max-DD-lmd=1e-1',
'Ave-DD-lmd=1e-1'],
dtype='object')
Mean-CDaR portfolio¶
We now consider the maximization of the mean return subject to a CDaR constraint: $$ \begin{array}{ll} \underset{\w, \zeta, s}{\textsf{maximize}} & \w^\T\bmu - \lambda s\\ \textsf{subject to} & \zeta+\frac{1}{1-\alpha}\frac{1}{T}\sum_{t=1}^{T}\left[ \max_{1\le\tau\le t}\w^\T\mathbf{r}_{\tau}^{\sf cum} - \w^\T\mathbf{r}_t^{\sf cum} - \zeta \right]^+ \le s\\ & \mathbf{1}^\T\w=1,\quad \w\ge\mathbf{0}, \end{array} $$ which can be conveniently reformulated as the following LP: $$ \begin{array}{cl} \underset{\w, \{z_t\}, \zeta, \{u_t\}, s}{\textsf{maximize}} & \w^\T\bmu - \lambda s\\ \textsf{subject to} & \zeta+\frac{1}{1-\alpha}\frac{1}{T}\sum_{t=1}^{T}z_{t} \le s\\ & 0\leq z_{t}\geq u_t - \w^\T\mathbf{r}_t^{\sf cum} - \zeta, \quad t=1,\dots,T\\ & \w^\T\mathbf{r}_{t}^{\sf cum} \le u_t\\ & u_{t-1} \le u_t\\ & \mathbf{1}^\T\w=1,\quad \w\ge\mathbf{0}. \end{array} $$
def design_portfolioCDaR(X: pd.DataFrame, lmd: float = 1e-1, alpha: float = 0.95) -> np.ndarray:
T, N = X.shape
mu = X.mean().values
X_cum = X.cumsum()
X_cum_np = X_cum.to_numpy()
# Design portfolio
w = cp.Variable(N)
z = cp.Variable(T)
u = cp.Variable(T)
zeta = cp.Variable(1)
s = cp.Variable(1)
problem = cp.Problem(cp.Maximize(w @ mu - lmd * s),
[w >= 0, cp.sum(w) == 1,
zeta + (1 / (T * (1 - alpha))) * cp.sum(z) <= s,
z >= 0, z >= u - X_cum_np @ w - zeta,
u >= X_cum_np @ w,
u[1:] >= u[:-1]])
result = problem.solve()
w = w.value
# Force small values to zero
w[w < 1e-6] = 0
w = w/sum(w)
return w
w_CDaR095_lmd1e_3 = design_portfolioCDaR(X_log_trn, alpha=0.95, lmd=1e-3)
w_CDaR095_lmd1e_1 = design_portfolioCDaR(X_log_trn, alpha=0.95, lmd=1e-1)
w_CDaR099_lmd1e_3 = design_portfolioCDaR(X_log_trn, alpha=0.99, lmd=1e-3)
w_CDaR099_lmd1e_1 = design_portfolioCDaR(X_log_trn, alpha=0.99, lmd=1e-1)
# Put together all portfolios
portfolios_df["CDaR095-lmd=1e-3"] = w_CDaR095_lmd1e_3
portfolios_df["CDaR095-lmd=1e-1"] = w_CDaR095_lmd1e_1
portfolios_df["CDaR099-lmd=1e-3"] = w_CDaR099_lmd1e_3
portfolios_df["CDaR099-lmd=1e-1"] = w_CDaR099_lmd1e_1
portfolios_df
| GMVP | Markowitz | DR-alpha=1 | CVaR-alpha=0.97 | Max-DD-lmd=1e-1 | Ave-DD-lmd=1e-1 | CDaR095-lmd=1e-3 | CDaR095-lmd=1e-1 | CDaR099-lmd=1e-3 | CDaR099-lmd=1e-1 | |
|---|---|---|---|---|---|---|---|---|---|---|
| AAPL | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| NFLX | 0.000000 | 0.000000 | 0.000001 | 0.0 | 0.122339 | 0.505511 | 0.0 | 0.620817 | 0.0 | 0.620817 |
| TSCO | 0.325649 | 0.231824 | 0.483524 | 0.0 | 0.000000 | 0.145774 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| MGM | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| MSFT | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| FB | 0.000000 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
| AMZN | 0.621097 | 0.768176 | 0.516475 | 1.0 | 0.877661 | 0.348714 | 1.0 | 0.379183 | 1.0 | 0.379183 |
| GOOGL | 0.053254 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.000000 | 0.0 | 0.000000 | 0.0 | 0.000000 |
# Plot allocation
fig, ax = plt.subplots(figsize=(12, 4))
portfolios_df.plot.bar(rot=0, width=0.5, title="Portfolio allocation", ax=ax)
<Axes: title={'center': 'Portfolio allocation'}>
Let compare the performance (in-sample vs out-of-sample):
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
print("In-sample:")
print_table_performance_metrics(ret_all_trn)
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
In-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 135.80% | 37.78% | 2.46 | -0.256 |
| Markowitz | 149.18% | 38.21% | 2.58 | -0.243 |
| DR-alpha=1 | 137.74% | 38.26% | 2.46 | -0.266 |
| CVaR-alpha=0.97 | 157.48% | 40.87% | 2.52 | -0.227 |
| Max-DD-lmd=1e-1 | 154.41% | 40.54% | 2.51 | -0.222 |
| Ave-DD-lmd=1e-1 | 136.96% | 41.04% | 2.31 | -0.237 |
| CDaR095-lmd=1e-3 | 157.48% | 40.87% | 2.52 | -0.227 |
| CDaR095-lmd=1e-1 | 138.31% | 43.20% | 2.23 | -0.224 |
| CDaR099-lmd=1e-3 | 157.48% | 40.87% | 2.52 | -0.227 |
| CDaR099-lmd=1e-1 | 138.31% | 43.20% | 2.23 | -0.224 |
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
| DR-alpha=1 | 22.21% | 29.28% | 0.828 | -0.125 |
| CVaR-alpha=0.97 | 11.25% | 38.90% | 0.463 | -0.163 |
| Max-DD-lmd=1e-1 | 10.48% | 37.59% | 0.448 | -0.161 |
| Ave-DD-lmd=1e-1 | 9.37% | 35.52% | 0.426 | -0.144 |
| CDaR095-lmd=1e-3 | 11.25% | 38.90% | 0.463 | -0.163 |
| CDaR095-lmd=1e-1 | 4.62% | 39.59% | 0.307 | -0.155 |
| CDaR099-lmd=1e-3 | 11.25% | 38.90% | 0.463 | -0.163 |
| CDaR099-lmd=1e-1 | 4.62% | 39.59% | 0.307 | -0.155 |
Let us plot the cumulative PnL over time for the training and test sets:
pnl_trn = emp.cum_returns(ret_all_trn)
fig, ax = plt.subplots(figsize=(12,6))
pnl_trn.plot(title="Cumulative PnL during training set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during training set'}, xlabel='Date'>
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
Let's keep the CDaR0 portfolio with $\alpha=0.95$ and $\lambda=10^{-3}$:
portfolios_df.drop(columns=["CDaR095-lmd=1e-1", "CDaR099-lmd=1e-3", "CDaR099-lmd=1e-1"], inplace=True)
portfolios_df.columns
Index(['GMVP', 'Markowitz', 'DR-alpha=1', 'CVaR-alpha=0.97', 'Max-DD-lmd=1e-1',
'Ave-DD-lmd=1e-1', 'CDaR095-lmd=1e-3'],
dtype='object')
Final comparison of DR, CVaR, and DD portfolios¶
We now perform a final comparison of the selected portfolios:
- GMVP
- Markowitz's mean variance portfolio
- DR ($\alpha=1$)
- CVaR ($\alpha=0.97$)
- DD:
- Max-DD ($\alpha=10^{-1}$)
- Ave-DD ($\alpha=10^{-1}$)
- CDaR ($\alpha=0.95$ and $\lambda=10^{-3}$).
# Compute returns of all portfolios
ret_all = X_lin @ portfolios_df
ret_all_trn = ret_all.iloc[:T_trn, ]
ret_all_tst = ret_all.iloc[T_trn:, ]
print("Out-of-sample:")
print_table_performance_metrics(ret_all_tst)
Out-of-sample:
| Annualized Return | Annualized Volatility | Sharpe Ratio | Maximum Drawdown | |
|---|---|---|---|---|
| GMVP | 17.50% | 30.95% | 0.672 | -0.136 |
| Markowitz | 16.74% | 33.68% | 0.624 | -0.144 |
| DR-alpha=1 | 22.21% | 29.28% | 0.828 | -0.125 |
| CVaR-alpha=0.97 | 11.25% | 38.90% | 0.463 | -0.163 |
| Max-DD-lmd=1e-1 | 10.48% | 37.59% | 0.448 | -0.161 |
| Ave-DD-lmd=1e-1 | 9.37% | 35.52% | 0.426 | -0.144 |
| CDaR095-lmd=1e-3 | 11.25% | 38.90% | 0.463 | -0.163 |
pnl_tst = emp.cum_returns(ret_all_tst)
fig, ax = plt.subplots(figsize=(12,6))
pnl_tst.plot(title="Cumulative PnL during test set", ax=ax)
<Axes: title={'center': 'Cumulative PnL during test set'}, xlabel='Date'>
However, this is a single backtest and more exhaustive backtesting should be performed