Carteira de variância mínima

A mistura mais segura

Combinar ativos reduz o risco, mas quanto depende dos pesos. A carteira de variância mínima é a escolha de pesos, de soma 1, com a menor variância possível. Não precisa de nenhuma previsão de retornos, só da matriz de covariância, o que a torna popular: retornos esperados são muito difíceis de estimar e covariâncias bem menos. Para dois ativos a resposta é uma fórmula; para muitos, a solução de um sistema linear.

# Two assets: volatility 20% and 10%, correlation 0.3
def variance(w, vol1, vol2, rho):
    return w * w * vol1 ** 2 + (1 - w) ** 2 * vol2 ** 2 + 2 * w * (1 - w) * rho * vol1 * vol2

vol1, vol2, rho = 0.20, 0.10, 0.3
w = (vol2 ** 2 - rho * vol1 * vol2) / (vol1 ** 2 + vol2 ** 2 - 2 * rho * vol1 * vol2)
print(round(w, 4), round(variance(w, vol1, vol2, rho) ** 0.5, 4))        # 0.1053 0.0979
print(round(variance(0.0, vol1, vol2, rho) ** 0.5, 4))                   # 0.1      all in the safe asset: riskier than the mix

Muitos ativos: um sistema linear

Para minimizar w @ cov @ w sujeito a sum(w) = 1, anula-se a derivada do lagrangiano. O resultado é w = cov^-1 * 1 / (1' cov^-1 1): resolve-se o sistema cov @ x = ones e reescala-se x para que os pesos somem 1. A variância mínima em si é 1 / (1' cov^-1 1). No código usa-se np.linalg.solve(cov, ones), não np.linalg.inv(cov) @ ones: é mais rápido e preciso, pois nunca forma a inversa.

# Minimum-variance weights of three assets
import numpy as np

cov = np.array([[0.0400, 0.0060, 0.0100],
                [0.0060, 0.0100, 0.0020],
                [0.0100, 0.0020, 0.0225]])

x = np.linalg.solve(cov, np.ones(3))
weights = x / x.sum()
print(np.round(weights, 4), round(float(weights.sum()), 4))        # [0.0192 0.7082 0.2726] 1.0
print(round(float(weights @ cov @ weights), 6), round(1 / float(x.sum()), 6))      # 0.007742 twice: the same number

# No other mix with weights summing to 1 does better: try 5000 random ones
import numpy as np

cov = np.array([[0.0400, 0.0060, 0.0100],
                [0.0060, 0.0100, 0.0020],
                [0.0100, 0.0020, 0.0225]])
x = np.linalg.solve(cov, np.ones(3))
best = x / x.sum()

rng = np.random.default_rng(0)
trial = rng.normal(size=(5000, 3))
trial = trial / trial.sum(axis=1, keepdims=True)                  # each row sums to 1
variances = np.einsum("ij,jk,ik->i", trial, cov, trial)            # w @ cov @ w for every row
print(round(float(variances.min()), 6), round(float(best @ cov @ best), 6))
print(bool(variances.min() >= best @ cov @ best))                  # True

Vendas a descoberto e restrições

A fórmula permite pesos negativos: pode vender um ativo a descoberto para proteger outro. Muitos investidores não podem ou não querem e desejam pesos somente comprados. Zerar os pesos negativos e reescalar é um conserto rápido que mantém pesos válidos, mas não é o verdadeiro ótimo sem vendas a descoberto, que exige um solucionador numérico (programação quadrática), porque a restrição w >= 0 torna o problema sujeito a desigualdades. A carteira truncada ao menos pode ser mantida e é fácil de comparar com a livre.

# The unconstrained solution shorts an asset; clip it and compare the risks
import numpy as np

cov = np.array([[0.04, 0.0342, 0.0],
                [0.0342, 0.0324, 0.0],
                [0.0, 0.0, 0.0225]])        # assets 1 and 2: volatility 20% and 18%, correlation 0.95

x = np.linalg.solve(cov, np.ones(3))
free = x / x.sum()
clipped = np.clip(free, 0, None)
clipped = clipped / clipped.sum()
print(np.round(free, 4), round(float(free @ cov @ free), 6))
print(np.round(clipped, 4), round(float(clipped @ cov @ clipped), 6))

• A variância mínima só precisa da matriz de covariância: para dois ativos, (vol2**2 - rho * vol1 * vol2) / (vol1**2 + vol2**2 - 2 * rho * vol1 * vol2) no ativo 1.
• Em geral w = solve(cov, ones) / sum(...) e a variância mínima é 1 / (1' cov^-1 1); use np.linalg.solve, não a inversa.
• A resposta livre pode vender ativos a descoberto; truncar em zero e reescalar é um conserto rápido, não o ótimo verdadeiro, e os pesos são frágeis ao erro de estimação.

A seguir: a otimização média-variância, acrescentar os retornos esperados para achar o melhor equilíbrio entre retorno e risco.

Lab: o que é avaliado

• Misturar dois ativos com menor risco com two_asset_weight25 pts
• Resolver os pesos mais seguros com min_variance_weights25 pts
• Informar o menor risco com min_variance25 pts
• Descartar as vendas a descoberto com long_only_weights25 pts