Simulação de Risco Monte Carlo — Modelando Resultados de Portfólio

As simulações de Monte Carlo permitem modelar mais de 100.000 cenários futuros potenciais do seu portfólio, quantificando métricas de risco como Value at Risk (VaR) e perda esperada. Em vez de assumir um único resultado, você vê a distribuição de possibilidades.

Exemplo: Execute 100k simulações da sua estratégia de trading. Você verá: 68% dos resultados lucram $10-$50, 25% perdem $10-$30, 5% perdem $50-$200 e 2% lucram $100+. Agora você entende seu perfil de risco.

Movimento Browniano Geométrico Básico (GBM)

Modele preços futuros como caminhos aleatórios com tendência e volatilidade:

Python — Caminhos de preço Monte Carlo
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0: preço atual, mu: tendência, sigma: volatilidade
# T: horizonte temporal (dias), dt: passo de tempo, n_sims: simulações
steps = int(T / dt)
paths = np.zeros((n_sims, steps))
paths[:, 0] = S0
for i in range(1, steps):
# dS = mu*S*dt + sigma*S*sqrt(dt)*Z
Z = np.random.normal(0, 1, n_sims)
dS = mu * paths[:, i-1] * dt + sigma * paths[:, i-1] * np.sqrt(dt) * Z
paths[:, i] = paths[:, i-1] + dS
return paths

Métricas de Risco de Portfólio

Value at Risk (VaR)

A perda que você excederia em apenas 5% dos cenários (95% de confiança):

Python — Calcular VaR
def calculate_var(simulations, confidence=0.95):
pnl = simulations[:, -1] - simulations[:, 0]
var = np.percentile(pnl, (1 - confidence) * 100)
return var # ex., -$2.340

Expected Shortfall (CVaR)

Perda média nos piores 5% dos casos:

Python — Calcular CVaR
def calculate_cvar(simulations, confidence=0.95):
pnl = simulations[:, -1] - simulations[:, 0]
var_threshold = np.percentile(pnl, (1 - confidence) * 100)
worst_5_pct = pnl[pnl <= var_threshold]
cvar = np.mean(worst_5_pct)
return cvar # ex., -$3.800 (pior que VaR)

Simulação Específica de Estratégia

Simule suas regras de trading reais, não apenas caminhos de preço:

Python — Monte Carlo de Estratégia
def simulate_strategy(capital, win_rate, avg_win, avg_loss, trades_per_day=10, days=30, n_sims=10000):
results = np.zeros(n_sims)
for sim in range(n_sims):
equity = capital
n_trades = trades_per_day * days
for _ in range(n_trades):
if np.random.rand() < win_rate:
pnl = np.random.normal(avg_win, avg_win * 0.2)
else:
pnl = -np.random.normal(avg_loss, avg_loss * 0.2)
equity += pnl
if equity < capital * 0.5:
break # Stop-out em 50% de perda
results[sim] = equity
return results

Teste de Estresse com Sinais Smart Money

Modele cenários de pior caso quando a confiança do Smart Money cai:

Python — Cenários de teste de estresse
def stress_test_scenarios(base_win_rate):
# Cenário 1: Condições normais (ALTA confiança)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Cenário 2: Sinais deteriorados (MÉDIA confiança)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Cenário 3: Colapso (condição VETO)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # vantagem negativa
return {
'normal': {'var': np.percentile(scenario_normal, 5), 'mean': np.mean(scenario_normal)},
'medium': {'var': np.percentile(scenario_medium, 5), 'mean': np.mean(scenario_medium)},
'veto': {'var': np.percentile(scenario_veto, 5), 'mean': np.mean(scenario_veto)}
}

Interpretação

De 10k simulações, você aprende:

Teste de estresse de estratégias com sinais Smart Money

Entenda o risco do portfólio em condições normais, deterioradas e VETO do Smart Money. Nossa API fornece os sinais; o Monte Carlo modela os resultados.

Modele o Risco Hoje →