← Alle Insights
11 Min. Lesezeit · Machine Learning · Mai 2027

LSTM für Preis-Prognose: Architektur, Training, Realität.

LSTMs sind das erste Werkzeug, zu dem viele Quants greifen, wenn sie Deep Learning ins Trading bringen. Recurrent, sequenzfähig, gut dokumentiert. Was die Tutorials verschweigen: Die Architektur ist nur ein kleiner Teil. Der Unterschied zwischen einem Spielzeug-Modell und einer produktiven Prognose liegt in Daten-Pipeline, Feature-Engineering und ehrlicher Validierung.

Warum LSTM und nicht klassische Zeitreihen?

ARIMA, GARCH und Exponential-Smoothing sind statistisch sauber, aber linear oder stark eingeschränkt in der Form ihrer Abhängigkeiten. Märkte verhalten sich nicht linear. Volatilitäts-Cluster, Regime-Wechsel, asymmetrische Reaktionen auf News — all das lässt sich mit klassischen Modellen nur approximieren. LSTMs lernen beliebige nichtlineare Funktionen über Sequenzen und merken sich Zustände über hunderte von Zeitschritten.

Der Preis dafür: höhere Modellkomplexität, längere Trainingszeiten, mehr Daten- bedarf und massiv höheres Overfitting-Risiko. Wer ein LSTM auf 500 Tagesbars trainiert, bekommt mit Sicherheit ein Modell, das in-sample perfekt aussieht und out-of-sample nichts wert ist.

Daten-Pipeline und Feature-Engineering.

Bevor das erste Modell läuft, entscheidet die Daten-Pipeline über Erfolg oder Misserfolg. Drei Bausteine sind unverzichtbar: 

import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset

class PriceSequenceDataset(Dataset):
    def __init__(self, returns, features, lookback=64, horizon=1):
        self.X, self.y = [], []
        arr = np.column_stack([returns.values, features.values])
        for i in range(lookback, len(arr) - horizon):
            self.X.append(arr[i - lookback:i])
            # Target: kumulierte Rendite ueber Horizon
            self.y.append(returns.iloc[i:i + horizon].sum())
        self.X = torch.tensor(np.array(self.X), dtype=torch.float32)
        self.y = torch.tensor(np.array(self.y), dtype=torch.float32)

    def __len__(self):
        return len(self.y)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

Sinnvolle Features neben dem reinen Return: realisierte Volatilität, RSI, Volume- Z-Score, Spread-Maße, Cross-Asset-Returns (z. B. VIX, DXY, 10y-Yield). Mehr ist nicht automatisch besser — jedes zusätzliche Feature erhöht das Overfitting-Risiko.

Architektur in PyTorch.

Eine bewährte Startarchitektur: zwei LSTM-Layer mit moderater Hidden-Size, Dropout zwischen den Layern, ein Dense-Layer als Kopf. Erst wenn das funktioniert, lohnt es, tiefer zu gehen. 

import torch
import torch.nn as nn

class PriceLSTM(nn.Module):
    def __init__(self, n_features, hidden=64, num_layers=2, dropout=0.2):
        super().__init__()
        self.lstm = nn.LSTM(
            input_size=n_features,
            hidden_size=hidden,
            num_layers=num_layers,
            dropout=dropout,
            batch_first=True,
        )
        self.head = nn.Sequential(
            nn.Linear(hidden, 32),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(32, 1),
        )

    def forward(self, x):
        out, _ = self.lstm(x)
        # nur letzten Zeitschritt nutzen
        last = out[:, -1, :]
        return self.head(last).squeeze(-1)

Wichtige Hyperparameter:

Training mit Walk-Forward-Validierung.

Klassisches train/val/test mit zufälligem Split ist im Trading falsch — es leakt Zukunft in Vergangenheit. Korrekt ist eine zeitlich expanding oder rolling Walk-Forward-Validierung: Trainiere auf [t0, t1], validiere auf [t1, t2], teste auf [t2, t3]. Verschiebe das Fenster und wiederhole.

Verlustfunktion: MSE auf Returns ist Standard, aber für Trading-Signale oft ungeeignet. Eine Klassifikation auf Richtung (long/short/flat) oder eine Sharpe-orientierte Verlustfunktion liefert in der Praxis robustere Signale. Wenn Sie auf Regression bleiben, kombinieren Sie MSE mit einer Direction-Penalty.

Häufige Fehler und wie Sie sie vermeiden.

  1. Skalierung mit zukünftigen Daten: StandardScaler auf der gesamten Reihe gefittet — klassischer Look-Ahead-Bias. Immer nur auf Trainingsfenster fitten.
  2. Target-Leakage: Features enthalten implizit den zukünftigen Return (z. B. ein Indikator, der zentriert berechnet wurde).
  3. Zu kleines Universum: Ein Modell, das nur auf SPY trainiert wurde, hat in der Regel keine generalisierbaren Eigenschaften. Trainieren Sie multi-asset, wenn möglich.
  4. Vergleich gegen unfaire Baseline: Ein LSTM, das eine naive Persistence-Prognose nicht schlägt, ist wertlos. Immer gegen "Return = letzter Return" und "Return = 0" benchmarken.
  5. Single-Run-Ergebnisse: ein einzelnes Training mit fixem Seed ist kein Beweis. Mindestens 5–10 Seeds, Mittelwert und Streuung berichten.

Vom Modell zum handelbaren Signal.

Eine gute Prognose ist noch keine gute Strategie. Aus dem Output des LSTM wird erst durch Schwellwerte, Position-Sizing und Risiko-Filter ein handelbares Signal. Typische Schritte:

Realistische Erwartungen.

Ein LSTM ist kein Wundermittel. Auf Tagesdaten liquider Indizes liegt der zusätzliche Sharpe-Beitrag gegenüber einfachen Faktoren oft bei 0,1–0,3 — das ist signifikant, aber nicht spektakulär. Auf höherfrequenten Daten (Stunden, Minuten) sind die Margen größer, dort werden aber Latency, Slippage und Markt-Mikrostruktur entscheidend.

Wer von einem LSTM einen Sharpe von 3 erwartet, baut entweder mit Look-Ahead-Bias oder mit unrealistischen Kosten-Annahmen. Wer 0,3 zusätzlichen Sharpe konsistent über mehrere Marktphasen erreicht, hat einen echten Vorteil.

Sie wollen ein LSTM- oder Deep-Learning-Modul in Ihre Strategie integrieren? Erstgespräch buchen — wir bauen die Daten-Pipeline und das Training so auf, dass das Modell in Live-Bedingungen hält.