Simulación de Riesgo Monte Carlo — Modelado de Resultados de Portafolio

Las simulaciones Monte Carlo te permiten modelar más de 100,000 posibles trayectorias futuras de tu portafolio, cuantificando métricas de riesgo como el Valor en Riesgo (VaR) y el déficit esperado. En lugar de asumir un único resultado, ves la distribución de posibilidades.

Ejemplo: Ejecuta 100k simulaciones de tu estrategia de trading. Verás: 68% de los resultados generan ganancias de $10-$50, 25% pierden $10-$30, 5% pierden $50-$200 y 2% ganan $100+. Ahora entiendes tu perfil de riesgo.

Movimiento Browniano Geométrico Básico (GBM)

Modela precios futuros como caminos aleatorios con tendencia y volatilidad:

Python — Trayectorias de precios Monte Carlo
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0: precio actual, mu: tendencia, sigma: volatilidad
# T: horizonte temporal (días), dt: paso de tiempo, n_sims: simulaciones
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 Riesgo del Portafolio

Valor en Riesgo (VaR)

La pérdida que excederías solo en el 5% de los escenarios (95% de confianza):

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

Déficit Esperado (CVaR)

Pérdida promedio en el peor 5% de los 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 # ej., -$3,800 (peor que VaR)

Simulación Específica de Estrategia

Simula tus reglas de trading reales, no solo trayectorias de precios:

Python — Monte Carlo de Estrategia
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 al 50% de pérdida
results[sim] = equity
return results

Pruebas de Estrés con Señales Smart Money

Modela escenarios de peor caso cuando la confianza de Smart Money disminuye:

Python — Escenarios de prueba de estrés
def stress_test_scenarios(base_win_rate):
# Escenario 1: Condiciones normales (confianza ALTA)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Escenario 2: Señales deterioradas (confianza MEDIA)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Escenario 3: Colapso (condición VETO)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # borde negativo
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)}
}

Interpretación

De 10k simulaciones, aprendes:

Prueba de estrés de estrategias con señales Smart Money

Comprende el riesgo del portafolio bajo condiciones normales, deterioradas y VETO de Smart Money. Nuestra API te da las señales; Monte Carlo modela los resultados.

Modelo de Riesgo Hoy →