Monte-Carlo für Portfolios: Risiko mit simulierten Pfaden.

Monte-Carlo ist das mächtigste Werkzeug im Risk-Management — und das mit dem höchsten Missbrauchspotenzial. Wer ein paar Tausend Pfade simuliert, fühlt sich schnell sicher. Tatsächlich entscheidet aber das, was vor der Simulation passiert: die Wahl der Verteilung, die Modellierung der Abhängigkeiten, der Umgang mit Tail-Risiken. Ein ehrlicher Blick auf den ganzen Weg, mit Python-Code und Erfahrung aus dem Alltag.

Was Monte-Carlo kann — und was nicht.

Die Idee ist simpel: statt eine Verteilung analytisch zu lösen, generiert man tausende mögliche Zukunftsszenarien und liest die Statistik daraus ab. Vorteil: man kann beliebige Portfolio-Strukturen bewerten, Optionen, Pfadabhängigkeiten, Multi-Asset. Nachteil: jede Simulation ist nur so gut wie das zugrundeliegende Modell.

Wer aus einer multivariaten Normalverteilung simuliert, bekommt schöne Bilder und unrealistische Tails. Wer aus historischen Renditen bootstrapped, bekommt realistischere Tails, aber keine Krisen, die noch nicht passiert sind. Wer mit t-Copulas und stochastischer Volatilität arbeitet, bekommt ein realistisches Bild — und Modellrisiko, das er erklären muss.

Schritt 1: Einzelpfad mit Geometric Brownian Motion.

Das Standardmodell für Aktien. Logarithmische Renditen sind normalverteilt, der Preis folgt einer geometrischen Brownschen Bewegung. Mathematisch sauber, in der Realität zu zahm — aber ein guter Ausgangspunkt.

import numpy as np

def simulate_gbm(S0: float, mu: float, sigma: float,
                 T: float, steps: int, n_paths: int, seed: int = 42):
    """Simuliert n_paths Pfade einer GBM über T Jahre mit steps Schritten."""
    rng = np.random.default_rng(seed)
    dt = T / steps
    # Standard-Normal-Schocks
    Z = rng.standard_normal((n_paths, steps))
    # Inkremente in Log-Returns
    increments = (mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
    # Kumulieren und exponentieren
    log_paths = np.cumsum(increments, axis=1)
    paths = S0 * np.exp(log_paths)
    # Startwert vorne anhängen
    return np.hstack([np.full((n_paths, 1), S0), paths])

# Beispiel: 10.000 Pfade über 1 Jahr, täglich
paths = simulate_gbm(S0=100, mu=0.08, sigma=0.20,
                     T=1.0, steps=252, n_paths=10_000)
final = paths[:, -1]
print(f"Mittlerer Endwert: {final.mean():.2f}")
print(f"5 %-Quantil: {np.quantile(final, 0.05):.2f}")

Schritt 2: Korrelierte Multi-Asset-Simulation.

Sobald mehr als ein Asset im Spiel ist, kommt die Korrelationsstruktur ins Spiel. Der saubere Weg: Cholesky-Zerlegung der Kovarianzmatrix. Damit lassen sich aus unabhängigen Standard-Normal-Schocks korrelierte Renditen erzeugen.

def simulate_correlated_gbm(S0: np.ndarray, mu: np.ndarray, cov: np.ndarray,
                            T: float, steps: int, n_paths: int, seed: int = 42):
    """Multi-Asset-GBM mit Korrelationsstruktur via Cholesky."""
    rng = np.random.default_rng(seed)
    n_assets = len(S0)
    dt = T / steps
    # Cholesky: L mit L @ L.T = cov
    L = np.linalg.cholesky(cov * dt)
    # Unabhängige Schocks ziehen und korrelieren
    Z = rng.standard_normal((n_paths, steps, n_assets))
    # Korrelation einbauen
    correlated = np.einsum('ij,nsj->nsi', L, Z)
    # Drift hinzufügen
    drift = (mu - 0.5 * np.diag(cov)) * dt
    log_returns = drift + correlated
    # Auf Pfade kumulieren
    log_paths = np.cumsum(log_returns, axis=1)
    paths = S0 * np.exp(log_paths)
    return paths

# Beispiel: zwei Assets mit Korrelation 0.6
cov = np.array([[0.04, 0.024], [0.024, 0.0625]])
paths = simulate_correlated_gbm(
    S0=np.array([100, 50]), mu=np.array([0.07, 0.10]),
    cov=cov, T=1.0, steps=252, n_paths=5_000)

Schritt 3: Fat Tails und Sprünge.

Die Normalverteilung versagt im Tail. Wer ehrliche Risiko-Zahlen will, muss alternative Verteilungen prüfen. Drei pragmatische Varianten:

• t-Verteilung: mit 3–6 Freiheitsgraden modelliert sie Fat Tails ohne großen Aufwand. Multivariat über t-Copulas — die Korrelationsstruktur bleibt erhalten, die Marginalverteilungen werden heavy-tailed.
• Merton-Jump-Diffusion: zur GBM kommt ein Poisson-Sprung-Prozess hinzu. Erfasst die plötzlichen, seltenen Bewegungen, die in normalen Returns fehlen.
• Bootstrap mit Krisenperioden: Resampling aus tatsächlichen historischen Renditen — inklusive 2008, 2020, anderer Stresszeiten. Maximale Realitätsnähe, eingeschränkte Flexibilität.

Schritt 4: Portfolio-Bewertung pro Pfad.

Sobald die Pfade stehen, wird das Portfolio in jedem Szenario bewertet. Für lineare Instrumente reicht eine Matrixmultiplikation. Für Optionen muss in jedem Pfad voll bewertet werden — entweder analytisch (Black-Scholes), per Baum oder geschachteltem Monte-Carlo. Das treibt die Rechenzeit, lässt sich aber gut parallelisieren.

Wer mit Python arbeitet: NumPy-Vektorisierung schafft Faktor 10–100 gegenüber einer Schleife. Wer mehr will, setzt auf Numba oder JAX und kommt nochmal Faktor 10 schneller. Bei Portfolios mit 1.000 Optionen über 10.000 Pfade ist das der Unterschied zwischen 5 Sekunden und 5 Minuten.

Schritt 5: Auslesen der Ergebnisse.

Aus der Verteilung der Portfolio-Endwerte ergeben sich alle relevanten Kennzahlen: mittlerer Gewinn, VaR, Expected Shortfall, Wahrscheinlichkeit eines bestimmten Verlustes, Tail-Quantile. Wichtig ist, sich nicht nur eine Zahl anzusehen — sondern das ganze Histogramm. Auffällige Bimodalität oder Asymmetrie zeigt strukturelle Eigenschaften, die in einer einzelnen Kennzahl untergehen.

Konvergenz und Konfidenzintervalle.

Monte-Carlo-Schätzer konvergieren mit 1/√n. 10.000 Pfade reichen für stabile Mittelwerte, aber nicht für stabile 99 %-Quantile. Faustregel: pro Quantil-Stelle mindestens 10.000 Pfade in der Tail-Region. Für 99 %-ES bedeutet das mindestens 100.000 Pfade insgesamt — sonst hängt die Zahl an wenigen Extremwerten.

Wer die Streuung der Schätzung quantifizieren will, lässt mehrere unabhängige Simulationen mit verschiedenen Seeds laufen und schaut sich die Spannweite an. Schwankt der ES zwischen den Läufen um mehr als 5 %, ist die Pfadzahl zu klein.

Variance Reduction.

Wer schneller konvergieren will, ohne mehr Pfade zu rechnen, setzt auf Varianz- Reduktionstechniken. Antithetic Variates sind kostenlos und halbieren oft die Varianz: zu jedem Z auch -Z generieren, beide Pfade rechnen. Importance Sampling lohnt sich, wenn man gezielt Tail-Quantile schätzt — man simuliert verzerrt im Tail und gewichtet zurück.

Wo wir Monte-Carlo wirklich einsetzen.

Drei Anwendungen prägen unseren Alltag. Erstens: ES und Stress für Portfolios mit Optionen und nichtlinearen Auszahlungen. Zweitens: Bewertung pfadabhängiger Strukturen — Knock-Outs, Asiatische Optionen, Auto-Calls. Drittens: Stochastische Backtests für Strategien, die wir nicht mit historischen Daten allein validieren können, weil zu wenig Stresshistorie da ist.

Monte-Carlo ersetzt keine andere Methode. Aber wer ein realistisches Bild seiner Tail-Risiken haben will, kommt um die Simulation nicht herum. Wichtig bleibt der kritische Blick: jede Simulation ist eine Hypothese über die Welt, kein Foto davon.

Sie wollen ein Monte-Carlo-Setup für Ihr Portfolio aufbauen oder bestehende Simulationen auf Modellrisiken prüfen? Erstgespräch buchen — wir bauen ein Setup, das nicht nur schöne Zahlen produziert.