Monte Carlo Risicosimulatie — Modelleer Portefeuille-uitkomsten

Monte Carlo-simulaties laten je 100.000+ potentiële toekomstige paden van je portefeuille modelleren, waarbij risicometrieken zoals Value at Risk (VaR) en expected shortfall worden gekwantificeerd. In plaats van één uitkomst aan te nemen, zie je de verdeling van mogelijkheden.

Voorbeeld: Voer 100k simulaties uit van je handelsstrategie. Je ziet: 68% van de uitkomsten levert $10-$50 winst op, 25% verliest $10-$30, 5% verliest $50-$200 en 2% behaalt $100+ winst. Nu begrijp je je risicoprofiel.

Basis Geometrische Brownse Beweging (GBM)

Modelleer toekomstige prijzen als random walks met drift en volatiliteit:

Python — Monte Carlo-prijspaden
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0: huidige prijs, mu: drift, sigma: volatiliteit
# T: tijdshorizon (dagen), dt: tijdstap, n_sims: simulaties
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

Portefeuille Risicometrieken

Value at Risk (VaR)

Het verlies dat je in slechts 5% van de scenario's zou overschrijden (95% betrouwbaarheid):

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

Expected Shortfall (CVaR)

Gemiddeld verlies in de slechtste 5% van de gevallen:

Python — Bereken 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 # bijv., -$3,800 (erger dan VaR)

Strategie-specifieke Simulatie

Simuleer je daadwerkelijke handelsregels, niet alleen prijspaden:

Python — Strategie Monte Carlo
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 bij 50% verlies
results[sim] = equity
return results

Stresstesten met Smart Money-signalen

Modelleer worst-case scenario's wanneer Smart Money-vertrouwen daalt:

Python — Stresstestscenario's
def stress_test_scenarios(base_win_rate):
# Scenario 1: Normale omstandigheden (HOOG vertrouwen)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Scenario 2: Verslechterende signalen (MEDIUM vertrouwen)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Scenario 3: Ineenstorting (VETO-conditie)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # negatieve edge
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)}
}

Interpretatie

Uit 10k simulaties leer je:

Stresstest strategieën met Smart Money-signalen

Begrijp portefeuillerisico onder normale, verslechterende en VETO Smart Money-omstandigheden. Onze API geeft je de signalen; Monte Carlo modelleert de uitkomsten.

Risicomodel Vandaag →