Simulation de risque Monte Carlo — Modélisation des résultats de portefeuille

Les simulations Monte Carlo vous permettent de modéliser plus de 100 000 trajectoires futures potentielles de votre portefeuille, en quantifiant des métriques de risque comme la Value at Risk (VaR) et l'expected shortfall. Au lieu de supposer un seul résultat, vous voyez la distribution des possibilités.

Exemple : Exécutez 100k simulations de votre stratégie de trading. Vous verrez : 68 % des résultats génèrent un profit de 10 $ à 50 $, 25 % perdent 10 $ à 30 $, 5 % perdent 50 $ à 200 $, et 2 % profitent de 100 $ ou plus. Maintenant, vous comprenez votre profil de risque.

Mouvement brownien géométrique de base (GBM)

Modélisez les prix futurs comme des marches aléatoires avec dérive et volatilité :

Python — Trajectoires de prix Monte Carlo
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0 : prix actuel, mu : dérive, sigma : volatilité
# T : horizon temporel (jours), dt : pas de temps, n_sims : simulations
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étriques de risque du portefeuille

Value at Risk (VaR)

La perte que vous dépasseriez dans seulement 5 % des scénarios (confiance à 95 %) :

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

Expected Shortfall (CVaR)

Perte moyenne dans les 5 % des cas les plus défavorables :

Python — Calculer le 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 # par exemple, -3 800 $ (pire que la VaR)

Simulation spécifique à la stratégie

Simulez vos règles de trading réelles, pas seulement les trajectoires de prix :

Python — Monte Carlo de stratégie
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 # Arrêt à 50 % de perte
results[sim] = equity
return results

Tests de résistance avec les signaux Smart Money

Modélisez les scénarios du pire cas lorsque la confiance des Smart Money baisse :

Python — Scénarios de test de résistance
def stress_test_scenarios(base_win_rate):
# Scénario 1 : Conditions normales (confiance ÉLEVÉE)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Scénario 2 : Signaux en détérioration (confiance MOYENNE)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Scénario 3 : Effondrement (condition VETO)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # désavantage
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)}
}

Interprétation

À partir de 10k simulations, vous apprenez :

Testez la résistance des stratégies avec les signaux Smart Money

Comprenez le risque du portefeuille dans des conditions normales, en détérioration et VETO des Smart Money. Notre API vous fournit les signaux ; Monte Carlo modélise les résultats.

Modèle de risque aujourd'hui →