Wie der Algorithmus von Jim Simons im Schlaf Geld druckt (Das exakte Quant-Framework)

Der erfolgreichste Hedgefonds aller Zeiten hatte nie ein Verlustjahr. In 34 Versuchen. Hier ist das exakte System – jede Formel, jedes Signal, ausführbarer Code.

Frühjahr 1988. Ein Mathematiker, der seine Karriere damit verbracht hatte, Codes aus dem Kalten Krieg zu knacken, betrat ein Handelsbüro und tat etwas, das niemand an der Wall Street je versucht hatte: Er feuerte alle Händler und ersetzte sie durch Signal-Detektoren.

Sein Name war Jim Simons. Sein Fonds hieß Medallion. Die Ergebnisse: 60 Milliarden Dollar an Performancegebühren, die den Märkten entzogen wurden. 30 Milliarden Dollar Nettovermögen allein für Simons. 39 % jährliche Rendite nach einer 44-prozentigen Performancegebühr. Kein einziges Verlustjahr in 34 Versuchen.

Jeder Quant auf dieser Plattform hat diese Zahlen gesehen. Fast niemand weiß, was tatsächlich unter der Haube läuft.

Bis jetzt.

EBENE 1: Die Signalerkennungs-Engine

Renaissance handelt nicht auf der Grundlage von Nachrichten. Es liest keine 10-Ks. Simons' Team setzt auf datengetriebene Methoden, nutzt statistische Analysen und Rechenleistung, um Marktineffizienzen zu identifizieren – sammelt enorme Datenmengen und analysiert sie, um statistische Muster und nicht-zufällige Ereignisse in einer breiten Palette von Märkten zu finden.

Die erste Schicht ist ein Muster-Extraktor. Stellen Sie es sich wie einen Seismografen vor – nicht zur Messung von Erdbeben, sondern der unsichtbaren Erschütterungen in Preisdaten, die großen Bewegungen vorausgehen.

Hier ist das Python-Gerüst:

1import numpy as np
2import pandas as pd
3from scipy import stats
4
5def detect_signal(prices: pd.Series, lookback: int = 20) -> dict:
6    returns = prices.pct_change().dropna()
7
8    # Autokorrelation – sagt die heutige Rendite die morgige voraus?
9    acf_1 = returns.autocorr(lag=1)
10
11    # Z-Score-Abweichung vom rollierenden Mittelwert
12    rolling_mean = returns.rolling(lookback).mean()
13    rolling_std  = returns.rolling(lookback).std()
14    z_score      = (returns - rolling_mean) / rolling_std
15
16    # Hurst-Exponent – ist diese Serie trendend oder mittelwertumkehrend?
17    hurst = compute_hurst(prices.values)
18
19    return {
20        "autocorrelation": acf_1,
21        "z_score_latest": z_score.iloc[-1],
22        "hurst_exponent": hurst,   # <0,5 = mittelwertumkehrend, >0,5 = trendend
23        "regime": "trending" if hurst > 0.55 else "mean_reverting"
24    }
25
26def compute_hurst(ts):
27    lags = range(2, 20)
28    tau  = [np.sqrt(np.std(np.subtract(ts[lag:], ts[:-lag]))) for lag in lags]
29    m    = np.polyfit(np.log(lags), np.log(tau), 1)
30    return m[0] * 2.0

Was Ihnen das sagt: Wenn hurst < 0,45, ist der Vermögenswert mittelwertumkehrend – Fades funktionieren. Wenn hurst > 0,55, ist er trendend – Momentum funktioniert. Medallion wechselt die Strategien basierend auf genau dieser Art von Regime-Erkennung.

EBENE 2: Das Faktormodell (Warum sich Aktien bewegen, bevor irgendjemand weiß, warum)

Seriöse Quant-Operationen ziehen Optionsketten, Orderbuch-Tiefe, Fundamentalaten (Gewinne, Umsätze, Cashflow), Unternehmensereignisse, Nachrichtenstimmung, Social-Media-Volumen und zunehmend alternative Datensätze wie Satellitenbilder, anonymisierte Kreditkartentransaktionen, Web-Traffic, App-Downloads und Schiffscontainerbewegungen heran.

Renaissance identifiziert, warum Preisbewegungen stattfinden, indem es Renditen in Faktoren zerlegt. Das Fama-French-5-Faktor-Modell ist die öffentliche Version davon. Die private Version von Renaissance geht über 200+ Faktoren tief.

1from sklearn.linear_model import LinearRegression
2
3def factor_decompose(returns: pd.DataFrame, factors: pd.DataFrame) -> dict:
4    """
5    returns: DataFrame der Vermögensrenditen
6    factors: DataFrame der Faktorrenditen (Markt, Größe, Wert, Momentum, usw.)
7    """
8    model = LinearRegression()
9    model.fit(factors, returns)
10
11    alpha     = model.intercept_          # Rendite, die nicht durch Faktoren erklärt wird = reiner Edge
12    betas     = model.coef_               # Faktor-Exposures
13    r_squared = model.score(factors, returns)
14
15    return {
16        "alpha": alpha,    # Danach suchen Sie – ist alpha > 0?
17        "betas": dict(zip(factors.columns, betas)),
18        "r_squared": r_squared,
19        "edge_quality": "strong" if abs(alpha) > 0.001 and r_squared > 0.3 else "weak"
20    }

Hohes Alpha + niedriges R-squared = Ihr Edge wird nicht durch bekannte Faktoren erklärt. Das ist Medallion-Territorium.

EBENE 3: Die Markov-Ketten-Regime-Maschine

Eines der am häufigsten genannten Geheimnisse der Top-Quant-Fonds ist die Regime-Erkennung – zu wissen, in welchem Marktzustand Sie sich befinden, bevor Sie handeln. Natural Language Processing scannt Nachrichtenartikel und soziale Medien und extrahiert Erkenntnisse über die öffentliche Stimmung, aber das tiefere Regime-Signal kommt von der Preisstruktur selbst.

Markov-Ketten modellieren die Wahrscheinlichkeit des Übergangs zwischen Marktzuständen:

1import numpy as np
2
3# Zustände: 0=Bull, 1=Bär, 2=Stagnierend
4# Übergangsmatrix, geschätzt aus historischen Daten
5transition_matrix = np.array([
6    [0.78, 0.14, 0.08],  # Von Bull: 78% bleiben Bull, 14% gehen zu Bär, 8% Stagnierend
7    [0.20, 0.68, 0.12],  # Von Bär: 20% erholen sich, 68% bleiben Bär, 12% Stagnierend
8    [0.25, 0.23, 0.52],  # Von Stagnierend: 25% Bull, 23% Bär, 52% bleiben
9])
10
11def get_next_regime(current_state: int, steps: int = 5) -> np.ndarray:
12    """Gibt die Wahrscheinlichkeitsverteilung über die Zustände nach N Schritten zurück."""
13    state_vec = np.zeros(3)
14    state_vec[current_state] = 1.0
15
16    for _ in range(steps):
17        state_vec = state_vec @ transition_matrix
18
19    return {
20        "bull_probability":     round(state_vec[0], 3),
21        "bear_probability":     round(state_vec[1], 3),
22        "stagnant_probability": round(state_vec[2], 3),
23        "dominant_regime":      ["Bull", "Bär", "Stagnierend"][np.argmax(state_vec)]
24    }

Wenn das Modell eine 76-prozentige Wahrscheinlichkeit besagt, in den nächsten 5 Perioden im Bärenregime zu bleiben – Sie gehen nicht long.

EBENE 4: Der Neuronale-Netz-Edge-Extraktor

KI-Systeme nutzen Deep Learning, um Handelssignale in Echtzeit zu generieren und auszuführen, mit verstärkendem Lernen, um Handelsstrategien kontinuierlich zu optimieren und das Timing für Ein- und Ausstiege zu verbessern.

Die neuronalen Netze extrahieren nichtlineare Beziehungen, die keine Formel erfassen kann:

1import torch
2import torch.nn as nn
3
4class QuantEdgeNet(nn.Module):
5    def __init__(self, input_features: int = 50):
6        super().__init__()
7        self.layers = nn.Sequential(
8            nn.Linear(input_features, 128),
9            nn.ReLU(),
10            nn.Dropout(0.2),
11            nn.Linear(128, 64),
12            nn.ReLU(),
13            nn.Linear(64, 3)    # Ausgabe: [long, short, flat] Wahrscheinlichkeiten
14        )
15
16    def forward(self, x):
17        return torch.softmax(self.layers(x), dim=-1)
18
19# Trainingssignal: kombiniere Faktorwerte + Regime-Wahrscheinlichkeiten + rohe Preiseigenschaften
20def build_feature_vector(prices, factors, regime_probs):
21    signal = detect_signal(prices)
22    return np.concatenate([
23        prices.pct_change().tail(20).values,   # Letzte 20 Renditen
24        list(factors.values()),                 # Faktor-Exposures
25        list(regime_probs.values()),            # Markov-Regime-Wahrscheinlichkeiten
26        [signal["hurst_exponent"],
27         signal["z_score_latest"]]
28    ])

Die entscheidende Erkenntnis: Sie sagen nicht den Preis voraus. Sie sagen die Wahrscheinlichkeit der Richtung voraus. Selbst 52 % Genauigkeit – wenn Sie Kelly-größenmäßig richtig einsetzen – druckt Geld.

EBENE 5: Die Ausführungsebene (Wo 80 % der Quants ausbluten)

Renaissance muss eine Infrastruktur aufgebaut haben, die die Ausführungskosten sehr niedrig hält – die berichteten Bruttorenditen liegen nach Handelskosten vor, was Medallions Performance noch außergewöhnlicher macht.

Die meisten Einzelhandels-Quants verlieren ihren Edge bei der Ausführung. Die Lösung:

1def kelly_position_size(
2    win_probability: float,
3    win_loss_ratio:  float,
4    max_risk_pct:    float = 0.02   # Niemals mehr als 2 % pro Trade riskieren
5) -> float:
6    kelly_fraction = win_probability - (1 - win_probability) / win_loss_ratio
7    kelly_fraction = max(0, kelly_fraction)             # Niemals negativ Kelly short
8    half_kelly      = kelly_fraction * 0.5              # Halbes Kelly zur Sicherheit
9    return min(half_kelly, max_risk_pct)                # Harte Obergrenze bei 2%
10
11def calculate_execution_cost(
12    spread_bps: float,
13    market_impact_bps: float,
14    shares: int,
15    price: float
16) -> float:
17    total_bps    = spread_bps + market_impact_bps
18    cost_per_share = price * total_bps / 10_000
19    return cost_per_share * shares
20
21# Nur den Trade eingehen, wenn Edge > Ausführungskosten
22def should_trade(edge_bps: float, execution_cost_bps: float) -> bool:
23    return edge_bps > (execution_cost_bps * 1.5)   # Mindestens 1,5-fache Kostenabdeckung erforderlich

DAS MEDALLION-SPIELBUCH: Alle 5 Ebenen

1Roh-Marktdaten
2      ↓
3[L1] Signalerkennung   → Hurst · ACF · Z-Score
4      ↓
5[L2] Faktormodell       → α-Extraktion · β-Exposure
6      ↓
7[L3] Markov-Regime      → Bull · Bär · Stagnierend
8      ↓
9[L4] Neuronales Netz    → Long · Short · Flat
10      ↓
11[L5] Kelly + Ausführung → Positionsgröße · Kostenfilter · Einstieg
12      ↓
13    Trade / Kein Trade

Jeder andere Quant-Fonds beschäftigt Tausende. Renaissance hat insgesamt 400 Leute, vielleicht 200, die an den Modellen arbeiten. Jeder andere Fonds hat mehrere konkurrierende Strategien. Renaissance hat ein Modell, an dem alle gemeinsam arbeiten.

Das ist das Geheimnis, über das niemand spricht: Der Edge ist keine einzelne Formel. Es ist die Pipeline – jede Schicht filtert Rauschen heraus, bis nur noch statistische Sicherheit übrig bleibt.

DIE ZAHLEN LÜGEN NICHT

Die meisten Quant-Strategien sterben an Überanpassung. Medallion überlebt, weil:

1. Sie zeigen das vollständige System nie Außenstehenden – das Alpha bleibt erhalten.
2. Sie haben sich für externes Geld geschlossen – die Kapazität bleibt erhalten.
3. Sie verwenden halbes Kelly – sie überleben Drawdowns, die überhebte Quants töten.
4. Jedes Signal wird zuerst out-of-sample getestet – keine Datenlecks.

Bis 2025 wurde mehr als 75 % des US-Aktienhandelsvolumens von quantitativen oder algorithmischen Systemen angetrieben. Der Markt ist quantitativ. Ihr Edge ist der Bau der besten Pipeline.

Der obige Code ist Ihr Ausgangspunkt. Jede Formel ist ausführbar. Jede Schicht ist stapelbar.

Jetzt bauen Sie Ihre eigene.

Danke fürs Lesen, ich würde mich über QT freuen!

Über mich: Ich bin Venus, eine leitende Quant-Systemarchitektin und Backend-Ingenieurin mit Erfahrung im Aufbau von Startups von 0→1 und der Skalierung von Produkten von 1→100 in den Bereichen KI, Cloud und Fintech x DeFi-Infrastruktur.