Multi-Symbol-Validierung: Teste deine Strategie auf allen Paaren

Artikel aus der Serie "Backtests ohne Illusionen"

Du hast eine Strategie auf ETHUSDT optimiert. 25 Monate Daten, 12+ Parameter. Der Backtest zeigt PnL +55 %, 500 Trades, MaxDD -0,9 %, Position 15 % der Zeit offen. Die Equity-Kurve steigt gleichmäßig an. Die Parameter haben die Plateau-Analyse bestanden — das Optimum sieht breit aus. Walk-Forward liefert einen WFER > 0,6. Monte-Carlo-Bootstrap zeigt ein positives 5. Perzentil.

Alles ist perfekt. Bis auf eine Sache: Du hast die Strategie an einem einzigen Instrument getestet.

Du startest denselben Algorithmus mit denselben Parametern auf BTCUSDT — PnL +8 %. Auf SOLUSDT — PnL -12 %. Auf DOGEUSDT — PnL -34 %. Die Strategie, die auf ETH alle Prüfungen bestanden hat, erweist sich bei den meisten anderen Paaren als unprofitabel.

Das ist kein Bug. Das ist die Single-Symbol-Falle — eine der häufigsten und heimtückischsten Formen des Overfittings im Algotrading.

Die Falle des einzelnen Instruments

Eine Strategie an einem einzigen Symbol zu optimieren bedeutet im Grunde, sie an die Preisdynamik eines bestimmten Assets anzupassen. Selbst wenn du Walk-Forward durchgeführt hast, selbst wenn Bootstrap breite Konfidenzintervalle zeigt — all diese Prüfungen wurden innerhalb einer einzigen Zeitreihe durchgeführt.

Walk-Forward prüft die Robustheit über die Zeit: Funktionieren die Parameter auf zukünftigen Daten desselben Instruments. Monte Carlo prüft die Robustheit über die Trade-Reihenfolge: Übersteht die Strategie eine andere Sequenz. Aber keine dieser Methoden prüft die Robustheit über Instrumente hinweg: Funktioniert die Strategie auf anderen Assets mit anderen Eigenschaften.

Wenn eine Strategie nur auf ETHUSDT profitabel ist — hat sie nicht eine Marktineffizienz erfasst, sondern die spezifische Struktur der Preisreihe von ETH:

• Charakteristische Candlestick-Muster, die für ETH einzigartig sind
• Bestimmte Volatilitätsniveaus, auf die die Schwellenwerte abgestimmt sind
• Die Liquiditäts- und Mikrostruktur-Besonderheiten dieses bestimmten Paares
• Korrelation mit BTC, charakteristisch für eine bestimmte Periode

Nichts davon ist ein Edge. Das ist Curve Fitting auf Instrumentenebene.

Symbol-Gruppen (Tiers) im Kryptomarkt

Nicht alle Kryptowährungen sind gleich. Für eine aussagekräftige Multi-Symbol-Validierung musst du verstehen, dass Instrumente in Gruppen mit grundlegend unterschiedlichen Eigenschaften unterteilt werden.

Tier 1: Blue Chips (BTC, ETH)

Hohe Liquidität, relativ niedrige Volatilität, institutioneller Flow. Korrelation mit Makro (S&P 500, DXY, Fed-Zinsen). Tiefe Orderbücher, enge Spreads, stabile Funding Rates. Typische tägliche Volatilität: 2-4 %.

Tier 2: Large Caps (SOL, BNB, ADA, XRP, AVAX)

Moderate Liquidität, erhöhte Volatilität. Bewegungen werden oft von Sektordynamiken angetrieben (L1 vs. L2, DeFi vs. Infra). Funding Rates sind volatiler. Spreads sind breiter. Typische tägliche Volatilität: 4-6 %.

Tier 3: Mid Caps (DOGE, SHIB, PEPE, ARB, OP)

Meme-Coins und Narrativ-Token. Hohe Volatilität, geringe Korrelation mit fundamentalen Faktoren. Bewegungen werden durch Social Media, Listings und Narrative bestimmt. Dünne Orderbücher an manchen Börsen. Typische tägliche Volatilität: 6-10 %.

Tier 4: Low Caps (Neue Listings)

Extreme Volatilität, dünne Orderbücher, Manipulationsrisiko. Oft unzureichende Historie für einen vollständigen Backtest. Typische tägliche Volatilität: 10-20 %+.

Zusammenfassende Tabelle der Eigenschaften

Jeder Tier ist eine eigene "Welt" mit eigener Mikrostruktur. Eine für Tier 1 abgestimmte Strategie betritt beim Wechsel zu Tier 3 fremdes Terrain.

Methodik der Multi-Symbol-Validierung

Schritt 1: Optimierung an einem einzelnen Symbol

Wähle ein Symbol zur Optimierung — zum Beispiel ETHUSDT. Führe die gesamte Pipeline durch: Optuna-Optimierung, Plateau-Analyse, Walk-Forward. Fixiere die Parameter.

Schritt 2: Test an Symbolen desselben Tiers

Führe die Strategie mit denselben Parametern an 5-10 Symbolen desselben Tiers aus. Für Tier 1 ist dies begrenzt (BTC + ETH), aber für Tier 2 und Tier 3 gibt es genügend Symbole.

Schritt 3: Test an Symbolen anderer Tiers

Führe die Strategie an 3-5 Symbolen jedes anderen Tiers aus. Dies ist der härteste Test: Wenn die Strategie sowohl auf ETHUSDT (Tier 1) als auch auf DOGEUSDT (Tier 3) funktioniert, ist die Wahrscheinlichkeit von Curve Fitting minimal.

Schritt 4: Ergebnisse nach Gruppe analysieren

Aggregiere die Metriken nach Tier und bewerte die Cross-Symbol-Robustheit.

Metriken für jedes Symbol

Erfasse für jedes Symbol:

• PnL — Gesamtrendite
• MaxDD — maximaler Drawdown
• N Trades — Anzahl der Trades
• Win Rate — Anteil profitabler Trades
• PnL/aktiver Tag — Rendite pro Einheit aktiver Zeit (mehr Details in PnL nach aktiver Zeit)

Bestehenskriterien

Eine Strategie besteht die Multi-Symbol-Validierung, wenn:

1. Profitabel bei >= 60 % der Symbole im gleichen Tier
2. Der durchschnittliche PnL über die Gruppe ist positiv
3. MaxDD steigt nicht dramatisch an (nicht mehr als 2-3x im Verhältnis zum Optimierungssymbol)
4. Wenn die Strategie NUR auf dem Optimierungssymbol profitabel ist — ablehnen

Beispiel: Drei Strategien, drei Ergebnisse

Betrachten wir ein konkretes Beispiel. Drei Strategien (Strategie A, Strategie B, Strategie C), optimiert auf ETHUSDT, getestet an 12 Symbolen aus vier Tiers.

Strategie A (optimiert auf ETHUSDT)

Parameter: PnL +55 %, ~500 Trades, ~15 % aktive Zeit, MaxDD ~0,9 %.

* — Optimierungssymbol

Ergebnisse nach Tier:

Fazit: Strategie A funktioniert bei Tier 1-2, versagt aber vollständig bei Tier 3. Dies ist eine typische Strategie, die auf ein Umfeld mit niedriger Volatilität abgestimmt ist. Für ein Portfolio aus Blue Chips und Large Caps — akzeptabel. Für universellen Einsatz — nein.

Strategie B (optimiert auf ETHUSDT)

Parameter: PnL +25 %, ~40 Trades, ~5 % aktive Zeit.

Ergebnisse nach Tier:

Fazit: Strategie B ist bei 9 von 11 Symbolen profitabel (82 %). Der durchschnittliche PnL ist über alle Tiers hinweg positiv. MaxDD wächst mit dem Tier auf vorhersehbare Weise. Dies ist eine robuste Strategie mit einem echten Markt-Edge. Trotz des bescheideneren PnL auf dem Optimierungssymbol (+25 % vs. +55 %) ist Strategie B deutlich zuverlässiger als Strategie A.

Strategie C (optimiert auf ETHUSDT)

Parameter: PnL +300 %, ~400 Trades, ~45 % aktive Zeit, MaxDD ~17 %.

Fazit: Strategie C ist klassisches Overfitting. +301 % auf ETHUSDT, aber katastrophale Verluste bei den meisten anderen Paaren. MaxDD bei Tier 3 übersteigt 70 % — das ist Kapitalvernichtung. Die Strategie hat einzigartige Muster von ETH erfasst, keine Marktineffizienz. Ablehnen.

Warum Strategien bei anderen Symbolen zusammenbrechen

1. Volatilitäts-Mismatch

Der häufigste Grund. Die Strategieparameter sind auf ein bestimmtes Volatilitätsniveau abgestimmt. Wenn die Strategie eine Einstiegsschwelle von 2 % verwendet — ist dies für ETH mit 3 % täglicher Volatilität ein sinnvoller Filter. Für DOGE mit 8 % täglicher Volatilität löst diese Schwelle zu häufig aus und erzeugt eine Masse falscher Signale.

Ebenso ist ein 1 %-Stop-Loss für ETH angemessen, für PEPE hingegen normales "Rauschen", und der Stop wird dutzende Male am Tag ausgelöst.

2. Liquiditätsunterschiede

Die Strategie geht von sofortiger Orderausführung zum aktuellen Preis aus. Bei BTCUSDT mit $50M Orderbuchtiefe innerhalb von 5 bps — ist das realistisch. Bei ARBUSDT mit$200K Tiefe — bewegt deine $10K-Order den Preis, und die tatsächliche Ausführung wird um 0,05-0,2 % schlechter sein. Über 500 Trades hinweg sind das 25-100 %, die allein durch Slippage verloren gehen.

3. Markt-Mikrostruktur

Jedes Instrument hat seine eigene Mikrostruktur:

• Funding Rates: Bei BTC ist das Funding in einem Bullenmarkt konsistent positiv (+0,01 % alle 8 Stunden). Bei Meme-Coins kann das Funding von -0,3 % auf +0,5 % springen. Mehr Details — in Funding Rates fressen deinen Leverage.
• Spread: Bei Tier 1 beträgt der Spread 0,01 %, bei Tier 4 — 0,5 %. Eine Strategie mit kleinen Take-Profits kann nicht profitabel sein, wenn der Spread die Take-Größe übersteigt.
• Manipulationsmuster: Wicks, Spoofing, Wash Trading — äußern sich bei jedem Tier unterschiedlich.

4. Regime-Sensitivität

Altcoins verhalten sich in verschiedenen Marktphasen unterschiedlich:

• In einem Bullentrend übertreffen Altcoins BTC (Beta > 1)
• In einem Bärentrend fallen Altcoins stärker als BTC
• In einem Seitwärtsmarkt können Altcoins mit BTC korrelieren oder sich nach eigenen Narrativen bewegen

Eine in einer Phase an einem Symbol optimierte Strategie kann optimal auf den Lag/Lead genau dieses Symbols relativ zu BTC abgestimmt sein — und dieser Lag/Lead ändert sich, wenn sich das Regime verschiebt.

Adaptive Parameterskalierung

Eine Strategie mit identischen Parametern auf allen Symbolen laufen zu lassen, ist falsch. Aber eine vollständige Neu-Optimierung an jedem Symbol widerspricht dem eigentlichen Zweck der Multi-Symbol-Validierung (Parameter werden zu jedem Symbol "nativ").

Der Kompromiss ist die Parameternormalisierung nach Volatilität:

import numpy as np

def scale_params_by_volatility(
    base_params: dict,
    optimization_symbol_vol: float,
    target_symbol_vol: float,
    vol_sensitive_params: list[str],
) -> dict:
    """
    Scale strategy parameters by target symbol volatility.

    Args:
        base_params: parameters optimized on the original symbol
        optimization_symbol_vol: daily volatility of the optimization symbol
        target_symbol_vol: daily volatility of the target symbol
        vol_sensitive_params: list of volatility-sensitive parameters
    """
    vol_ratio = target_symbol_vol / optimization_symbol_vol
    adjusted = base_params.copy()

    for param in vol_sensitive_params:
        if param in adjusted:
            adjusted[param] = adjusted[param] * vol_ratio

    return adjusted

base_params = {
    "entry_threshold": 0.02,     # 2% — entry threshold
    "stop_loss": 0.01,           # 1% — stop loss
    "take_profit": 0.03,         # 3% — take profit
    "trailing_stop": 0.008,      # 0.8% — trailing stop
    "atr_multiplier": 2.5,       # ATR multiplier (not scaled)
    "rsi_period": 14,            # RSI period (not scaled)
    "ma_fast": 10,               # fast MA (not scaled)
    "ma_slow": 50,               # slow MA (not scaled)
}

vol_sensitive = ["entry_threshold", "stop_loss", "take_profit", "trailing_stop"]

eth_vol = 0.032     # 3.2%
doge_vol = 0.081    # 8.1%

doge_params = scale_params_by_volatility(
    base_params, eth_vol, doge_vol, vol_sensitive
)

print("ETH params:", {k: f"{v:.4f}" for k, v in base_params.items() if k in vol_sensitive})
print("DOGE params:", {k: f"{v:.4f}" for k, v in doge_params.items() if k in vol_sensitive})

Ausgabe:

ETH params:  {'entry_threshold': '0.0200', 'stop_loss': '0.0100', 'take_profit': '0.0300', 'trailing_stop': '0.0080'}
DOGE params: {'entry_threshold': '0.0506', 'stop_loss': '0.0253', 'take_profit': '0.0759', 'trailing_stop': '0.0203'}

Der Stop-Loss stieg von 1 % auf 2,53 % — passend für die 8,1 % tägliche Volatilität von DOGE. Ohne Skalierung würde ein 1 %-Stop dutzende Male durch "Rauschen" ausgelöst.

Wichtig: Skaliere nur Preisschwellen (Entries, Stops, Takes). Indikatorperioden (RSI, MA) und Multiplikatoren (ATR-Multiplikator) werden in der Regel nicht skaliert — sie sind bereits durch den Indikator selbst nach Volatilität normalisiert.

Zwei Validierungsmodi

1. Strikter Modus (ohne Skalierung): Ausführung mit identischen Parametern. Ein Test der absoluten Robustheit. Wenn die Strategie profitabel ist — ist der Edge stark.

2. Adaptiver Modus (mit Skalierung): Ausführung mit normalisierten Parametern. Ein Test der Robustheit der Strategielogik, mit der Zulassung, dass sich die Volatilitätsniveaus unterscheiden.

Wir empfehlen, beide Tests durchzuführen. Strikter Modus — um die "Stärke" des Edge zu bewerten. Adaptiver Modus — für die praktische Anwendung.

Cross-Symbol-Robustheitswert

Für die quantitative Bewertung der Multi-Symbol-Robustheit führen wir eine zusammengesetzte Metrik ein — den Cross-Symbol Robustness Score (CSRS).

Formel

$\text{CSRS} = w_1 \cdot R_{profit} + w_2 \cdot R_{pnl} + w_3 \cdot P_{consistency} - w_4 \cdot P_{variance}$

wobei:

• $R_{profit}$ — Anteil profitabler Symbole:

$R_{profit} = \frac{N_{profitable}}{N_{total}}$

• $R_{pnl}$ — normalisierter liquiditätsgewichteter durchschnittlicher PnL:

$R_{pnl} = \frac{\sum_{i=1}^{N} l_i \cdot \text{PnL}_i}{\sum_{i=1}^{N} l_i}$

wobei $l_i$ die Liquidität von Symbol $i$ ist (durchschnittliches tägliches Volumen).

• $P_{consistency}$ — Bonus für Cross-Tier-Konsistenz:

$P_{consistency} = \frac{N_{profitable\_tiers}}{N_{total\_tiers}}$

• $P_{variance}$ — Strafe für hohe PnL-Varianz zwischen Symbolen:

$P_{variance} = \frac{\sigma(\text{PnL}_1, \ldots, \text{PnL}_N)}{\max(|\bar{\text{PnL}}|, 0.01)}$

Standardgewichtungen

CSRS-Interpretation

Vollständige Implementierung: Multi-Symbol-Validierungs-Pipeline

import numpy as np
import pandas as pd
from dataclasses import dataclass, field
from typing import Callable, Optional

@dataclass
class SymbolResult:
    """Strategy result on a single symbol."""
    symbol: str
    tier: int
    pnl: float
    max_dd: float
    n_trades: int
    win_rate: float
    pnl_per_active_day: float
    avg_daily_volume: float  # liquidity

@dataclass
class TierResult:
    """Aggregated result by tier."""
    tier: int
    symbols: list[SymbolResult]
    n_symbols: int
    n_profitable: int
    profit_ratio: float
    avg_pnl: float
    avg_max_dd: float
    pnl_std: float

@dataclass
class MultiSymbolResult:
    """Full multi-symbol validation result."""
    symbol_results: list[SymbolResult]
    tier_results: list[TierResult]
    csrs: float
    passed: bool
    optimization_symbol: str
    report: str

SYMBOL_TIERS = {
    1: ["BTCUSDT", "ETHUSDT"],
    2: ["SOLUSDT", "BNBUSDT", "ADAUSDT", "XRPUSDT", "AVAXUSDT"],
    3: ["DOGEUSDT", "SHIBUSDT", "PEPEUSDT", "ARBUSDT", "OPUSDT"],
}

SYMBOL_VOLATILITY = {
    "BTCUSDT": 0.028, "ETHUSDT": 0.032,
    "SOLUSDT": 0.052, "BNBUSDT": 0.038, "ADAUSDT": 0.048,
    "XRPUSDT": 0.045, "AVAXUSDT": 0.055,
    "DOGEUSDT": 0.081, "SHIBUSDT": 0.092, "PEPEUSDT": 0.105,
    "ARBUSDT": 0.068, "OPUSDT": 0.063,
}

SYMBOL_VOLUME = {
    "BTCUSDT": 15e9, "ETHUSDT": 8e9,
    "SOLUSDT": 2e9, "BNBUSDT": 1.5e9, "ADAUSDT": 800e6,
    "XRPUSDT": 1.2e9, "AVAXUSDT": 500e6,
    "DOGEUSDT": 1e9, "SHIBUSDT": 400e6, "PEPEUSDT": 600e6,
    "ARBUSDT": 300e6, "OPUSDT": 250e6,
}


def run_multi_symbol_validation(
    strategy_fn: Callable,
    base_params: dict,
    optimization_symbol: str,
    data_loader: Callable,
    vol_sensitive_params: list[str],
    adaptive: bool = True,
    csrs_weights: tuple = (0.35, 0.25, 0.25, 0.15),
    min_profit_ratio: float = 0.6,
) -> MultiSymbolResult:
    """
    Full multi-symbol validation pipeline.

    Args:
        strategy_fn: strategy function (data, params) -> (pnl, max_dd, n_trades, win_rate, returns)
        base_params: parameters optimized on optimization_symbol
        optimization_symbol: optimization symbol
        data_loader: data loading function (symbol) -> np.ndarray
        vol_sensitive_params: parameters to scale by volatility
        adaptive: use volatility scaling
        csrs_weights: weights (w1, w2, w3, w4) for CSRS
        min_profit_ratio: minimum fraction of profitable symbols in a tier
    """
    w1, w2, w3, w4 = csrs_weights
    opt_vol = SYMBOL_VOLATILITY.get(optimization_symbol, 0.03)

    symbol_results = []

    for tier, symbols in SYMBOL_TIERS.items():
        for symbol in symbols:
            data = data_loader(symbol)
            if data is None or len(data) < 100:
                continue

            if adaptive and symbol != optimization_symbol:
                sym_vol = SYMBOL_VOLATILITY.get(symbol, 0.05)
                params = scale_params_by_volatility(
                    base_params, opt_vol, sym_vol, vol_sensitive_params
                )
            else:
                params = base_params.copy()

            pnl, max_dd, n_trades, win_rate, returns = strategy_fn(data, params)

            active_days = max(n_trades * 0.5, 1)  # rough estimate
            pnl_per_day = pnl / active_days

            symbol_results.append(SymbolResult(
                symbol=symbol,
                tier=tier,
                pnl=pnl,
                max_dd=max_dd,
                n_trades=n_trades,
                win_rate=win_rate,
                pnl_per_active_day=pnl_per_day,
                avg_daily_volume=SYMBOL_VOLUME.get(symbol, 1e6),
            ))

    tier_results = []
    tiers_present = sorted(set(r.tier for r in symbol_results))

    for tier in tiers_present:
        tier_symbols = [r for r in symbol_results if r.tier == tier]
        n_profitable = sum(1 for r in tier_symbols if r.pnl > 0)
        pnls = [r.pnl for r in tier_symbols]

        tier_results.append(TierResult(
            tier=tier,
            symbols=tier_symbols,
            n_symbols=len(tier_symbols),
            n_profitable=n_profitable,
            profit_ratio=n_profitable / len(tier_symbols) if tier_symbols else 0,
            avg_pnl=np.mean(pnls),
            avg_max_dd=np.mean([r.max_dd for r in tier_symbols]),
            pnl_std=np.std(pnls),
        ))

    all_pnls = [r.pnl for r in symbol_results]
    all_volumes = [r.avg_daily_volume for r in symbol_results]
    n_total = len(symbol_results)
    n_profitable = sum(1 for r in symbol_results if r.pnl > 0)

    r_profit = n_profitable / n_total if n_total > 0 else 0

    total_vol = sum(all_volumes)
    r_pnl_raw = sum(r.pnl * r.avg_daily_volume for r in symbol_results) / total_vol
    r_pnl = 1 / (1 + np.exp(-r_pnl_raw * 5))

    profitable_tiers = sum(1 for tr in tier_results if tr.avg_pnl > 0)
    p_consistency = profitable_tiers / len(tier_results) if tier_results else 0

    pnl_std = np.std(all_pnls) if len(all_pnls) > 1 else 0
    pnl_mean = np.mean(all_pnls) if all_pnls else 0.01
    p_variance = pnl_std / max(abs(pnl_mean), 0.01)
    p_variance = min(p_variance, 5.0)  # cap the penalty

    csrs = w1 * r_profit + w2 * r_pnl + w3 * p_consistency - w4 * (p_variance / 5.0)
    csrs = max(0, min(1, csrs))  # clamp to [0, 1]

    opt_tier = None
    for tier, symbols in SYMBOL_TIERS.items():
        if optimization_symbol in symbols:
            opt_tier = tier
            break

    same_tier_result = next((tr for tr in tier_results if tr.tier == opt_tier), None)
    passed = (
        csrs >= 0.5
        and (same_tier_result is None or same_tier_result.profit_ratio >= min_profit_ratio)
        and np.mean(all_pnls) > 0
    )

    report = _generate_report(
        symbol_results, tier_results, csrs, passed,
        optimization_symbol, adaptive
    )

    return MultiSymbolResult(
        symbol_results=symbol_results,
        tier_results=tier_results,
        csrs=csrs,
        passed=passed,
        optimization_symbol=optimization_symbol,
        report=report,
    )


def _generate_report(
    symbol_results, tier_results, csrs, passed,
    opt_symbol, adaptive
) -> str:
    """Generate text report."""
    lines = []
    lines.append("=" * 60)
    lines.append("MULTI-SYMBOL VALIDATION REPORT")
    lines.append(f"Optimization symbol: {opt_symbol}")
    lines.append(f"Mode: {'adaptive' if adaptive else 'strict'}")
    lines.append(f"CSRS: {csrs:.3f}")
    lines.append(f"Passed: {'YES' if passed else 'NO'}")
    lines.append("=" * 60)

    for tr in tier_results:
        lines.append(f"\n--- Tier {tr.tier} ---")
        lines.append(f"  Symbols: {tr.n_symbols}, Profitable: {tr.n_profitable} "
                      f"({tr.profit_ratio:.0%})")
        lines.append(f"  Avg PnL: {tr.avg_pnl:.2%}, Avg MaxDD: {tr.avg_max_dd:.2%}")
        lines.append(f"  PnL StdDev: {tr.pnl_std:.2%}")

        for sr in tr.symbols:
            marker = "*" if sr.symbol == opt_symbol else " "
            status = "+" if sr.pnl > 0 else "-"
            lines.append(
                f"  {marker} [{status}] {sr.symbol:12s} "
                f"PnL={sr.pnl:+.2%}  MaxDD={sr.max_dd:.2%}  "
                f"Trades={sr.n_trades:4d}  WR={sr.win_rate:.1%}"
            )

    lines.append("\n" + "=" * 60)
    return "\n".join(lines)

Beispiel für die Pipeline-Nutzung

def my_strategy(data, params):
    """Your strategy. Returns (pnl, max_dd, n_trades, win_rate, returns)."""
    pass

def load_ohlcv(symbol):
    """Load OHLCV data for a symbol."""
    pass

base_params = {
    "entry_threshold": 0.02,
    "stop_loss": 0.01,
    "take_profit": 0.03,
    "trailing_stop": 0.008,
    "atr_multiplier": 2.5,
    "rsi_period": 14,
    "ma_fast": 10,
    "ma_slow": 50,
}

result = run_multi_symbol_validation(
    strategy_fn=my_strategy,
    base_params=base_params,
    optimization_symbol="ETHUSDT",
    data_loader=load_ohlcv,
    vol_sensitive_params=["entry_threshold", "stop_loss", "take_profit", "trailing_stop"],
    adaptive=True,
)

print(result.report)
print(f"\nCSRS: {result.csrs:.3f}")
print(f"Passed: {result.passed}")

Wann Single-Symbol-Validierung akzeptabel ist

Nicht jede Strategie muss über mehrere Instrumente hinweg funktionieren. Es gibt legitime Fälle, in denen Single-Symbol ein normaler Ansatz ist:

Market Making auf einem bestimmten Orderbuch

Eine Market-Making-Strategie (z. B. unter Verwendung des Avellaneda-Stoikov-Modells) ist per Definition an ein bestimmtes Orderbuch gebunden. Die Parameter hängen von der spezifischen Mikrostruktur ab: Tiefe, Spread, Warteschlangenposition, Fill Rate. Ein Test an einem anderen Symbol ist bedeutungslos — es ist ein anderes Orderbuch.

Arbitrage zwischen bestimmten Paaren

Funding-Rate-Arbitrage oder Cross-Exchange-Arbitrage ist per Definition an bestimmte Instrumentenpaare gebunden. Die Validierung erfolgt hier auf anderen Börsen mit denselben Paaren, nicht auf unterschiedlichen Symbolen.

Strategien, die explizit einzigartige Asset-Eigenschaften nutzen

Wenn eine Strategie auf einer spezifischen Eigenschaft eines Assets basiert (z. B. die Korrelation von BTC mit der Hashrate oder die Korrelation von ETH mit den Gasgebühren), ist eine Multi-Symbol-Validierung nicht anwendbar. Solche Strategien sind jedoch selten.

In allen anderen Fällen — wenn die Strategie auf "generischen" Signalen basiert (MA-Crossover, RSI, Momentum, Mean Reversion) — ist die Multi-Symbol-Validierung obligatorisch. Wenn eine generische Strategie nur bei einem Symbol funktioniert, ist das kein Edge — es ist Overfitting.

Zusammenhang mit anderen Validierungsmethoden

Die Multi-Symbol-Validierung ist eine von drei orthogonalen Methoden des Out-of-Sample-Testings:

Jede Methode prüft die Robustheit entlang ihrer eigenen Achse. Eine Strategie kann Walk-Forward bestehen, aber bei Multi-Symbol scheitern (Curve Fitting auf das Instrument). Sie kann Multi-Symbol bestehen, aber bei Monte Carlo scheitern (abhängig von einer glücklichen Trade-Reihenfolge).

Maximaler Schutz vor Overfitting: Verwende alle drei Methoden.

Vollständige Validierungs-Pipeline:

1. Optimierung der Parameter an einem einzelnen Symbol
2. Plateau-Analyse — Prüfung der Optimum-Stabilität
3. Walk-Forward — Validierung entlang der Zeitachse (WFER > 0,5)
4. Multi-Symbol — Validierung entlang der Instrumentenachse (CSRS > 0,5)
5. Monte-Carlo-Bootstrap — Konfidenzintervalle (5. Perzentil > 0)
6. Berücksichtigung von Funding Rates und Verlust-Gewinn-Asymmetrie

Eine Strategie, die alle sechs Prüfungen besteht, hat eine minimale Wahrscheinlichkeit, ein Overfitting-Artefakt zu sein.

Erweiterungen: Symbolkorrelation und Kaskadenstrategien

Die Multi-Symbol-Validierung deckt noch einen weiteren Aspekt auf: Korrelationen zwischen Symbolen. Wenn eine Strategie bei BTC und ETH profitabel ist, aber bei allen Altcoins unprofitabel — ist das ein Hinweis darauf, dass der Edge an die hohe BTC-ETH-Korrelation gebunden ist. Eine detaillierte Analyse von Korrelationsstrukturen — im Artikel Signalkorrelation und Pairs Trading.

Für Strategieportfolios bestimmen Multi-Symbol-Ergebnisse, auf welchen Instrumenten eine Strategie gestartet werden sollte. Strategie A aus dem obigen Beispiel — nur Tier 1-2. Strategie B — Tier 1-3. Dies sind Eingabedaten für die Kaskaden-Orchestrierung, bei der unterschiedliche Strategien auf unterschiedlichen Instrumenten gestartet werden, abhängig von ihrem Robustheitsprofil.

Fazit

Multi-Symbol-Validierung ist keine Option — sie ist ein obligatorischer Schritt für jede Strategie, die einen verallgemeinerten Markt-Edge beansprucht. Wichtigste Erkenntnisse:

1. Eine Strategie, die nur bei einem Symbol funktioniert, ist höchstwahrscheinlich auf die Besonderheiten dieses Symbols überangepasst. Ausnahmen: Market Making, Arbitrage, Strategien basierend auf einzigartigen Asset-Eigenschaften.

2. Tier-Gruppierung ist obligatorisch. Du kannst Ergebnisse bei BTC (Tier 1) nicht mit Ergebnissen bei PEPE (Tier 3) vergleichen, ohne die Unterschiede in Volatilität, Liquidität und Mikrostruktur zu verstehen.

3. Adaptive Parameterskalierung — Schwellenwertnormalisierung nach Volatilität — verbessert die Realitätsnähe des Multi-Symbol-Testings erheblich.

4. CSRS > 0,5 — eine vernünftige Mindestschwelle. Die Strategie sollte bei >= 60 % der Symbole im selben Tier profitabel sein, und der durchschnittliche PnL über alle Symbole hinweg sollte positiv sein.

5. Walk-Forward + Multi-Symbol + Monte Carlo — drei orthogonale Validierungsachsen. Jede Methode erfasst, was die anderen übersehen. Verwende alle drei.

Eine Strategie mit PnL +25 % und CSRS 0,72 ist zuverlässiger als eine Strategie mit PnL +300 % und CSRS 0,18. Erstere verdient an einer Marktineffizienz. Letztere verdient am Auswendiglernen einer einzigen Preisreihe.

Nützliche Links

1. Lopez de Prado, M. — Advances in Financial Machine Learning (Wiley)
2. Pardo, R. — The Evaluation and Optimization of Trading Strategies (Wiley)
3. Bailey, D.H. et al. — The Probability of Backtest Overfitting
4. Aronson, D.R. — Evidence-Based Technical Analysis
5. Kevin Davey — Building Winning Algorithmic Trading Systems (Wiley)
6. Harvey, C.R. & Liu, Y. — Backtesting (2015)
7. Chan, E. — Algorithmic Trading: Winning Strategies and Their Rationale (Wiley)
8. Binance Research — Cryptocurrency Correlation Analysis
9. NumPy — numpy.random.choice
10. Pandas — DataFrame

Zitation

@article{soloviov2026multisymbolvalidation,
  author = {Soloviov, Eugen},
  title = {Multi-Symbol Validation: Test Your Strategy on All Pairs},
  year = {2026},
  url = {https://marketmaker.cc/en/blog/post/multi-symbol-validation},
  version = {0.1.0},
  description = {Why a strategy optimized on ETHUSDT may fail on altcoins. How to properly test across pair groups (blue chips, large caps, shitcoins) and what cross-symbol robustness score to consider sufficient.}
}