Simulazione di rischio Monte Carlo — Modellazione degli esiti del portafoglio

Le simulazioni Monte Carlo ti permettono di modellare oltre 100.000 percorsi futuri potenziali del tuo portafoglio, quantificando metriche di rischio come il Value at Risk (VaR) e l'expected shortfall. Invece di assumere un singolo risultato, vedi la distribuzione delle possibilità.

Esempio: Esegui 100k simulazioni della tua strategia di trading. Vedrai: il 68% degli esiti ha un profitto di $10-$50, il 25% perde $10-$30, il 5% perde $50-$200 e il 2% guadagna $100+. Ora comprendi il tuo profilo di rischio.

Moto Browniano Geometrico di base (GBM)

Modella i prezzi futuri come cammini casuali con deriva e volatilità:

Python — Percorsi dei prezzi Monte Carlo
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0: prezzo corrente, mu: deriva, sigma: volatilità
# T: orizzonte temporale (giorni), dt: passo temporale, n_sims: simulazioni
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

Metriche di rischio del portafoglio

Value at Risk (VaR)

La perdita che supereresti solo nel 5% degli scenari (confidenza del 95%):

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

Expected Shortfall (CVaR)

Perdita media nel peggiore 5% dei casi:

Python — Calcola il 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 # es., -$3,800 (peggio del VaR)

Simulazione specifica per strategia

Simula le tue regole di trading effettive, non solo i percorsi dei prezzi:

Python — Monte Carlo per strategie
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% di perdita
results[sim] = equity
return results

Stress test con segnali Smart Money

Modella gli scenari peggiori quando la fiducia degli Smart Money cala:

Python — Scenari di stress test
def stress_test_scenarios(base_win_rate):
# Scenario 1: Condizioni normali (confidenza ALTA)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Scenario 2: Segnali in deterioramento (confidenza MEDIA)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Scenario 3: Crollo (condizione VETO)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # vantaggio 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)}
}

Interpretazione

Da 10k simulazioni, impari:

Stress-test delle strategie con segnali Smart Money

Comprendi il rischio del portafoglio in condizioni normali, in deterioramento e VETO degli Smart Money. La nostra API ti fornisce i segnali; Monte Carlo modella i risultati.

Modello di rischio oggi →