Otimização de Portfólio — MPT, Fronteira Eficiente e Modelos de Fator

Retorno esperado:
E[Rₚ] = Σ wᵢ × E[Rᵢ] = wᵀμ

Variância (risco²):
σ²ₚ = Σᵢ Σⱼ wᵢwⱼ Cov(Rᵢ, Rⱼ) = wᵀΣw

Onde:
- μ: vetor de retornos esperados
- Σ: matriz de covariância dos retornos

Para 2 ativos com pesos iguais (50/50):
σ²ₚ = 0.25σ₁² + 0.25σ₂² + 2×0.25×Cov(R₁,R₂)

Se correlação = 1:  σₚ = (σ₁+σ₂)/2  — sem diversificação
Se correlação = 0:  σₚ < (σ₁+σ₂)/2  — diversificação parcial
Se correlação = -1: σₚ pode = 0     — diversificação perfeita

Minimizar: wᵀΣw           (minimizar risco)
Sujeito a: wᵀμ = μ_alvo   (atingir retorno alvo)
           Σwᵢ = 1          (pesos somam 100%)
           wᵢ ≥ 0           (sem short selling, se desejado)

import numpy as np
from scipy.optimize import minimize

def portfolio_variance(weights, cov_matrix):
    return weights @ cov_matrix @ weights

def portfolio_return(weights, returns):
    return weights @ returns

def efficient_frontier(mu, Sigma, num_points=100):
    n = len(mu)
    results = []

    for target_return in np.linspace(mu.min(), mu.max(), num_points):
        constraints = [
            {"type": "eq", "fun": lambda w: np.sum(w) - 1},
            {"type": "eq", "fun": lambda w, r=target_return: portfolio_return(w, mu) - r}
        ]
        bounds = [(0, 1)] * n

        result = minimize(
            portfolio_variance, x0=np.ones(n)/n,
            args=(Sigma,), method="SLSQP",
            constraints=constraints, bounds=bounds
        )

        if result.success:
            vol = np.sqrt(result.fun)
            results.append({"return": target_return, "vol": vol, "weights": result.x})

    return results

E[Rᵢ] = Rf + βᵢ × (E[Rm] - Rf)

Onde:
- Rf: taxa livre de risco
- βᵢ = Cov(Rᵢ, Rm) / Var(Rm): sensibilidade ao mercado
- E[Rm] - Rf: prêmio de risco do mercado

α = Rᵢ - [Rf + βᵢ(Rm - Rf)]

E[Rᵢ] = Rf + βᵢ×MKT + sᵢ×SMB + hᵢ×HML

- MKT: prêmio de mercado (market risk)
- SMB (Small Minus Big): ações pequenas superam grandes
- HML (High Minus Low): ações de valor (alto P/B) superam crescimento

# Framework simplificado de Black-Litterman
import numpy as np

def black_litterman(Sigma, w_eq, tau, P, Q, Omega):
    """
    Sigma: matriz de covariância
    w_eq: pesos do portfólio de equilíbrio
    tau: escalar de incerteza (típico: 0.05)
    P: matriz de views (k × n)
    Q: vetor de retornos das views (k × 1)
    Omega: covariância da incerteza nas views
    """
    # Retorno de equilíbrio implícito
    lambda_risk = 2.5  # aversão ao risco do mercado
    pi = lambda_risk * Sigma @ w_eq

    # Posterior BL
    M = np.linalg.inv(np.linalg.inv(tau*Sigma) + P.T @ np.linalg.inv(Omega) @ P)
    mu_bl = M @ (np.linalg.inv(tau*Sigma) @ pi + P.T @ np.linalg.inv(Omega) @ Q)

    return mu_bl

import numpy as np

def var_historico(retornos, confianca=0.95, horizonte=1):
    """VaR por simulação histórica"""
    quantil = np.percentile(retornos, (1 - confianca) * 100)
    return -quantil * np.sqrt(horizonte)

retornos_diarios = np.log(precos).diff().dropna()
var_95 = var_historico(retornos_diarios, 0.95)
print(f"VaR (95%, 1 dia): {var_95:.2%}")

def cvar(retornos, confianca=0.95):
    var = np.percentile(retornos, (1 - confianca) * 100)
    tail_losses = retornos[retornos <= var]
    return -tail_losses.mean()

from scipy.optimize import minimize

def risk_contribution(weights, cov_matrix):
    port_var = weights @ cov_matrix @ weights
    marginal_risk = cov_matrix @ weights
    risk_contrib = weights * marginal_risk / port_var
    return risk_contrib

def risk_parity_objective(weights, cov_matrix):
    rc = risk_contribution(weights, cov_matrix)
    target = np.ones(len(weights)) / len(weights)  # contribuição igual
    return np.sum((rc - target)**2)