CAPM e beta

Um número para o risco de mercado

A maioria das ações sobe quando o mercado sobe e cai quando ele cai. O beta de um ativo mede quanto: um beta de 1,5 significa que, em média, um movimento de 1% do mercado vem com 1,5% no ativo. É a inclinação dos retornos do ativo contra os do mercado, covariance(asset, market) / variance(market). O beta é a parte do risco que não se diversifica, porque todo ativo do mercado a carrega.

import numpy as np

market = np.array([0.01, -0.02, 0.015, 0.005, -0.01, 0.02])
asset = 1.5 * market + np.array([0.002, -0.001, 0.003, 0.0, -0.002, 0.001])      # moves 1.5x the market, plus noise

market_dev = market - market.mean()
covariance = np.sum((asset - asset.mean()) * market_dev) / (len(market) - 1)
variance = np.sum(market_dev ** 2) / (len(market) - 1)
print(round(float(covariance / variance), 4))                 # 1.5972: about 1.5, the noise moves it a little
print(round(float(np.polyfit(market, asset, 1)[0]), 4))       # the regression slope gives the same number

# Beta does not care about a constant, and scales with the asset
import numpy as np

def beta(asset, market):
    market_dev = market - market.mean()
    return float(np.sum((asset - asset.mean()) * market_dev) / np.sum(market_dev ** 2))

rng = np.random.default_rng(4)
market = rng.normal(0, 0.01, size=100)
print(round(beta(2.5 * market, market), 4))               # 2.5   an asset that moves 2.5x the market
print(round(beta(market + 0.01, market), 4))              # 1.0   adding a constant changes nothing
print(round(beta(-market, market), 4))                    # -1.0  a perfect hedge

O modelo de precificação de ativos de capital

O CAPM transforma isso em um preço do risco. Os investidores são pagos por assumir risco de mercado, e por nada mais; o retorno esperado de um ativo é a taxa livre de risco mais seu beta vezes o prêmio de risco de mercado (retorno do mercado menos a taxa livre de risco): E[R] = rf + beta * (E[R_m] - rf). Um beta 0 rende a taxa livre de risco, um beta 1 o retorno do mercado e um beta 2 a taxa livre de risco mais o dobro do prêmio.

def capm_expected_return(rf, beta_value, market_return):
    return rf + beta_value * (market_return - rf)

rf, market_return = 0.01, 0.06
for b in (0.0, 0.5, 1.0, 1.5, 2.0):
    print(b, round(capm_expected_return(rf, b, market_return), 4))     # 0.01, 0.035, 0.06, 0.085, 0.11

Alfa: o que sobra

Se o CAPM está certo, um ativo rende exatamente o retorno que seu beta justifica. A diferença entre o que rendeu e o que o CAPM esperava é o alfa de Jensen: mean(asset) - (rf + beta * (mean(market) - rf)). Um alfa positivo significa que fez melhor do que seu risco de mercado explica; é o que gestores ativos vendem e o mais difícil de achar. A parte do movimento que o mercado não explica é o risco residual, medido pelo desvio-padrão dos resíduos da regressão, que pode ser diversificado.

# Alpha and residual risk of an asset with a little skill in it
import numpy as np

rng = np.random.default_rng(2)
market = rng.normal(0.0004, 0.01, size=500)
asset = 0.0003 + 1.2 * market + rng.normal(0, 0.005, size=500)       # true alpha 3 bps a day, beta 1.2, residual 0.5%
rf = 0.0001

market_dev = market - market.mean()
b = np.sum((asset - asset.mean()) * market_dev) / np.sum(market_dev ** 2)
alpha = asset.mean() - (rf + b * (market.mean() - rf))
a = asset.mean() - b * market.mean()
residual = asset - (a + b * market)
print(round(float(b), 3), round(float(alpha), 5), round(float(np.sqrt(np.sum(residual ** 2) / (len(asset) - 2))), 4))

• Beta = covariance(asset, market) / variance(market), a inclinação contra o mercado; é a parte não diversificável do risco.
• CAPM: rf + beta * (market - rf); o alfa de Jensen é o retorno médio menos isso, a habilidade (ou sorte) além do risco de mercado.
• O risco residual é o desvio-padrão de asset - (a + b * market) com n - 2; pode ser diversificado; o próprio beta é ruidoso.

A seguir: os modelos multifatoriais (Fama–French), explicar retornos com mais do que o mercado.

Lab: o que é avaliado

• Medir a sensibilidade ao mercado com beta25 pts
• Precificar o risco com capm_expected_return25 pts
• Achar a habilidade, se houver, com jensen_alpha25 pts
• Medir o risco residual com residual_vol25 pts