Otimização média-variância

Retorno e risco em um único número

A variância mínima ignora os retornos. A otimização média-variância (Markowitz) usa ambos: um investidor quer um retorno esperado w @ mu alto e uma variância w @ cov @ w baixa. Uma forma simples de equilibrá-los é a utilidade w @ mu - 0.5 * lambda * w @ cov @ w, em que lambda é a aversão ao risco: quanto maior, mais custa uma unidade de variância. Dois investidores com as mesmas crenças mas lambda diferente escolhem carteiras diferentes, e a melhor carteira de cada um é o máximo de uma função suave e côncava.

import numpy as np

mu = np.array([0.08, 0.05, 0.10])                         # expected annual returns
cov = np.array([[0.0400, 0.0060, 0.0100],
                [0.0060, 0.0100, 0.0020],
                [0.0100, 0.0020, 0.0225]])

def utility(weights, mu, cov, risk_aversion):
    return weights @ mu - 0.5 * risk_aversion * weights @ cov @ weights

equal = np.full(3, 1 / 3)
print(round(float(equal @ mu), 4), round(float(equal @ cov @ equal), 4))      # 0.0767 0.0121
print(round(float(utility(equal, mu, cov, 4.0)), 4))                          # 0.0526

A melhor posição para uma dada aversão

Sem restrição orçamentária (o resto do dinheiro rende a taxa livre de risco, tomada aqui como zero em excesso), a melhor posição é onde o gradiente mu - lambda * cov @ w se anula: w = cov^-1 * mu / lambda. Em código, np.linalg.solve(cov, mu) / lambda. Escala como manda o bom senso: o dobro de aversão, metade da posição. A soma dos pesos é a necessária; o resto, 1 - w.sum(), é caixa.

# The best position for several risk aversions: more aversion, smaller bets
import numpy as np

mu = np.array([0.08, 0.05, 0.10])
cov = np.array([[0.0400, 0.0060, 0.0100],
                [0.0060, 0.0100, 0.0020],
                [0.0100, 0.0020, 0.0225]])

for aversion in (5.0, 10.0, 20.0):
    w = np.linalg.solve(cov, mu) / aversion
    print(aversion, np.round(w, 3), "invested", round(float(w.sum()), 3))

A carteira tangente

Com um ativo livre de risco, todos os investidores mantêm a mesma mistura de risco, só em quantidades diferentes. Essa mistura é a de maior índice de Sharpe (w @ mu - rf) / sqrt(w @ cov @ w), a carteira tangente: w proporcional a cov^-1 * (mu - rf), reescalada para somar 1. O investidor cauteloso põe só parte do dinheiro nela e o resto em caixa; o ousado toma emprestado para ter mais. Decidir quanto risco assumir e decidir quais ativos de risco manter são dois problemas separados.

# The tangency portfolio: no other mix of the three assets has a higher Sharpe ratio
import numpy as np

mu = np.array([0.08, 0.05, 0.10])
cov = np.array([[0.0400, 0.0060, 0.0100],
                [0.0060, 0.0100, 0.0020],
                [0.0100, 0.0020, 0.0225]])
rf = 0.02

x = np.linalg.solve(cov, mu - rf)
best = x / x.sum()

def sharpe(w):
    return (w @ mu - rf) / np.sqrt(w @ cov @ w)

rng = np.random.default_rng(1)
trials = rng.normal(size=(2000, 3))
trials = trials / trials.sum(axis=1, keepdims=True)
print(np.round(best, 4), round(float(sharpe(best)), 4))
print(round(max(float(sharpe(w)) for w in trials), 4))      # the best of 2000 random mixes comes close, never above

Atingir um retorno-alvo

Outra forma de fazer a pergunta: entre todas as carteiras que somam 1 e têm um retorno esperado dado, qual tem a menor variância? Com duas restrições, a solução é uma combinação dos dois vetores resolvidos s1 = cov^-1 * 1 e sm = cov^-1 * mu, com coeficientes de quatro números a, b, c, d que resumem o mercado. Cada retorno-alvo dá uma carteira; traçar o risco de todas é a fronteira eficiente do próximo tópico.

# Minimum-variance portfolios for three target returns
import numpy as np

mu = np.array([0.08, 0.05, 0.10])
cov = np.array([[0.0400, 0.0060, 0.0100],
                [0.0060, 0.0100, 0.0020],
                [0.0100, 0.0020, 0.0225]])
ones = np.ones(3)
s1, sm = np.linalg.solve(cov, ones), np.linalg.solve(cov, mu)
a, b, c = ones @ s1, ones @ sm, mu @ sm
d = a * c - b ** 2

for target in (0.06, 0.08, 0.09):
    w = ((c - b * target) * s1 + (a * target - b) * sm) / d
    print(target, np.round(w, 3), round(float(w @ mu), 4), round(float(np.sqrt(w @ cov @ w)), 4))

• A utilidade é w @ mu - 0.5 * lambda * w @ cov @ w; a melhor posição sem orçamento é solve(cov, mu) / lambda, e dobrar lambda a reduz à metade.
• Com um ativo livre de risco, a melhor mistura de risco é a carteira tangente solve(cov, mu - rf), reescalada para somar 1: o maior índice de Sharpe.
• Para um retorno-alvo, os pesos de variância mínima combinam solve(cov, ones) e solve(cov, mu); o resultado vale o que vale o mu estimado.

A seguir: a fronteira eficiente, a curva do melhor risco para cada nível de retorno.

Lab: o que é avaliado

• Pontuar uma carteira com utility25 pts
• Encontrar a melhor posição com utility_weights25 pts
• Maximizar o índice de Sharpe com tangency_weights25 pts
• Atingir uma meta de retorno com target_return_weights25 pts