Monte Carlo Risikosimulation — Modellierung von Portfolioergebnissen

Monte Carlo Simulationen ermöglichen es Ihnen, 100.000+ potenzielle zukünftige Pfade Ihres Portfolios zu modellieren und Risikokennzahlen wie Value at Risk (VaR) und erwarteten Verlust zu quantifizieren. Anstatt von einem einzigen Ergebnis auszugehen, sehen Sie die Verteilung der Möglichkeiten.

Beispiel: Führen Sie 100k Simulationen Ihrer Handelsstrategie durch. Sie werden sehen: 68 % der Ergebnisse erzielen einen Gewinn von $10-$50, 25 % verlieren $10-$30, 5 % verlieren $50-$200 und 2 % erzielen einen Gewinn von $100+. Jetzt verstehen Sie Ihr Risikoprofil.

Grundlegende geometrische Brownsche Bewegung (GBM)

Modellieren Sie zukünftige Preise als Zufallspfade mit Drift und Volatilität:

Python — Monte Carlo Preisverläufe
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0: aktueller Preis, mu: Drift, sigma: Volatilität
# T: Zeithorizont (Tage), dt: Zeitschritt, n_sims: Simulationen
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

Portfolio-Risikokennzahlen

Value at Risk (VaR)

Der Verlust, den Sie in nur 5 % der Szenarien überschreiten würden (95 % Konfidenz):

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

Expected Shortfall (CVaR)

Durchschnittlicher Verlust in den schlechtesten 5 % der Fälle:

Python — CVaR berechnen
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 # z.B. -$3,800 (schlimmer als VaR)

Strategiespezifische Simulation

Simulieren Sie Ihre tatsächlichen Handelsregeln, nicht nur Preisverläufe:

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 bei 50 % Verlust
results[sim] = equity
return results

Stresstests mit Smart Money Signalen

Modellieren Sie Worst-Case-Szenarien, wenn das Smart Money Vertrauen sinkt:

Python — Stresstest-Szenarien
def stress_test_scenarios(base_win_rate):
# Szenario 1: Normale Bedingungen (HOCHES Vertrauen)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Szenario 2: Verschlechternde Signale (MITTELES Vertrauen)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Szenario 3: Zusammenbruch (VETO-Bedingung)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # negativer Rand
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)}
}

Interpretation

Aus 10k Simulationen lernen Sie:

Stresstest-Strategien mit Smart Money Signalen

Verstehen Sie das Portfolio-Risiko unter normalen, sich verschlechternden und VETO Smart Money Bedingungen. Unsere API liefert Ihnen die Signale; Monte Carlo modelliert die Ergebnisse.

Risikomodell heute →