Çok Sembolli Doğrulama: Stratejinizi Tüm Pariteler Üzerinde Test Edin

"Yanılsamasız Backtestler" serisinden bir makale

ETHUSDT üzerinde bir strateji optimize ettiniz. 25 aylık veri, 12'den fazla parametre. Backtest PnL +%55, 500 işlem, MaxDD -%0,9, pozisyon açık kalma süresi %15 gösteriyor. Öz sermaye eğrisi düzgün bir şekilde yükseliyor. Parametreler plato analizini geçti — optimum geniş görünüyor. Walk-forward WFER > 0,6 veriyor. Monte Carlo bootstrap pozitif 5. yüzdelik dilim gösteriyor.

Her şey mükemmel. Tek bir şey dışında: stratejiyi tek bir enstrüman üzerinde test ettiniz.

Aynı algoritmayı aynı parametrelerle BTCUSDT üzerinde çalıştırıyorsunuz — PnL +%8. SOLUSDT üzerinde — PnL -%12. DOGEUSDT üzerinde — PnL -%34. ETH üzerinde tüm kontrolleri geçen strateji, diğer paritelerin büyük çoğunluğunda kârsız çıkıyor.

Bu bir hata değil. Bu tek sembol tuzağı — algoritmik ticarette aşırı uyumun (overfitting) en yaygın ve sinsi biçimlerinden biri.

Tek Enstrüman Tuzağı

Tek bir sembol üzerinde strateji optimize etmek, özünde onu belirli bir varlığın fiyat dinamiklerine uydurmaktır. Walk-forward çalıştırmış olsanız bile, bootstrap geniş güven aralıkları gösterse bile — tüm bu kontroller tek bir zaman serisi içinde gerçekleştirildi.

Walk-forward zaman genelinde sağlamlığı kontrol eder: parametreler aynı enstrümanın gelecekteki verileri üzerinde çalışıyor mu? Monte Carlo işlem sırası genelinde sağlamlığı kontrol eder: strateji farklı bir diziyi kaldırabilir mi? Ancak bu yöntemlerin hiçbiri enstrümanlar genelinde sağlamlığı kontrol etmez: strateji farklı özelliklere sahip diğer varlıklarda çalışıyor mu?

Bir strateji yalnızca ETHUSDT'de kârlıysa — bir piyasa verimsizliğini değil, ETH'nin fiyat serisinin özel yapısını yakalamış demektir:

• ETH'ye özgü karakteristik mum kalıpları
• Eşiklerin ayarlandığı belirli volatilite seviyeleri
• Bu özel paritenin likiditesi ve mikro yapı özellikleri
• Belirli bir döneme özgü BTC ile korelasyon

Bunların hiçbiri bir üstünlük (edge) değil. Bu enstrüman düzeyinde eğri uydurma (curve fitting).

Kripto Piyasasında Sembol Grupları (Katmanlar)

Tüm kripto para birimleri eşit değildir. Anlamlı çok sembolli doğrulama için, enstrümanların temelden farklı özelliklere sahip gruplara ayrıldığını anlamanız gerekir.

Katman 1: Blue Chip'ler (BTC, ETH)

Yüksek likidite, görece düşük volatilite, kurumsal akış. Makro ile korelasyon (S&P 500, DXY, Fed faiz oranları). Derin emir defterleri, dar spreadler, istikrarlı fonlama oranları. Tipik günlük volatilite: %2-4.

Katman 2: Büyük Cap'ler (SOL, BNB, ADA, XRP, AVAX)

Orta likidite, yüksek volatilite. Hareketler genellikle sektör dinamikleri tarafından yönlendirilir (L1 vs L2, DeFi vs altyapı). Fonlama oranları daha değişken. Spreadler daha geniş. Tipik günlük volatilite: %4-6.

Katman 3: Orta Cap'ler (DOGE, SHIB, PEPE, ARB, OP)

Meme coin'ler ve anlatı tokenleri. Yüksek volatilite, temel faktörlerle düşük korelasyon. Hareketler sosyal medya, listlemeler ve anlatılar tarafından belirlenir. Bazı borsalarda ince emir defterleri. Tipik günlük volatilite: %6-10.

Katman 4: Düşük Cap'ler (Yeni Listlemeler)

Aşırı volatilite, ince emir defterleri, manipülasyon riski. Genellikle tam backtest için yetersiz geçmiş. Tipik günlük volatilite: %10-20'den fazla.

Özelliklerin Özet Tablosu

Her katman, kendine özgü mikro yapıya sahip ayrı bir "dünya"dır. Katman 1 için ayarlanmış bir strateji, Katman 3'e geçtiğinde yabancı bir ortama girer.

Çok Sembolli Doğrulama Metodolojisi

Adım 1: Tek Sembol Üzerinde Optimize Et

Optimizasyon için bir sembol seçin — örneğin, ETHUSDT. Tam pipeline'ı çalıştırın: Optuna optimizasyonu, plato analizi, walk-forward. Parametreleri sabitleyin.

Adım 2: Aynı Katmandaki Semboller Üzerinde Test Et

Stratejiyi aynı parametrelerle aynı katmandan 5-10 sembol üzerinde çalıştırın. Katman 1 için bu sınırlıdır (BTC + ETH), ancak Katman 2 ve Katman 3 için yeterli sembol vardır.

Adım 3: Diğer Katmanlardaki Semboller Üzerinde Test Et

Stratejiyi diğer her katmandan 3-5 sembol üzerinde çalıştırın. Bu en zorlu testtir: strateji ETHUSDT (Katman 1) ve DOGEUSDT (Katman 3) üzerinde çalışıyorsa, eğri uydurma olasılığı minimumdur.

Adım 4: Sonuçları Gruba Göre Analiz Et

Metrikleri katmana göre topla ve çapraz sembol sağlamlığını değerlendir.

Her Sembol İçin Metrikler

Her sembol için kaydedin:

• PnL — toplam getiri
• MaxDD — maksimum düşüş
• N işlem — işlem sayısı
• Kazanma oranı — kârlı işlemlerin oranı
• PnL/aktif gün — aktif zaman birimi başına getiri (daha fazla ayrıntı için Aktif zaman bazlı PnL)

Geçme Kriterleri

Bir strateji şu durumlarda çok sembolli doğrulamayı geçer:

1. Aynı katmandaki sembollerin >= %60'ında kârlı
2. Grup genelinde ortalama PnL pozitif
3. MaxDD dramatik biçimde artmıyor (optimizasyon sembolüne göre en fazla 2-3 kat)
4. Strateji YALNIZCA optimizasyon sembolünde kârlıysa — reddet

Örnek: Üç Strateji, Üç Sonuç

Somut bir örneği ele alalım. ETHUSDT üzerinde optimize edilmiş ve dört katmanda 12 sembol üzerinde test edilmiş üç strateji (Strateji A, Strateji B, Strateji C).

Strateji A (ETHUSDT Üzerinde Optimize Edilmiş)

Parametreler: PnL +%55, ~500 işlem, ~%15 aktif süre, MaxDD ~%0,9.

* — optimizasyon sembolü

Katmana göre sonuçlar:

Karar: Strateji A Katman 1-2'de çalışıyor, ancak Katman 3'te tamamen başarısız oluyor. Bu, düşük volatilite ortamı için ayarlanmış tipik bir stratejidir. Blue chip'ler ve büyük cap'lerden oluşan bir portföy için — kabul edilebilir. Evrensel kullanım için — hayır.

Strateji B (ETHUSDT Üzerinde Optimize Edilmiş)

Parametreler: PnL +%25, ~40 işlem, ~%5 aktif süre.

Katmana göre sonuçlar:

Karar: Strateji B, 11 sembolün 9'unda (%82) kârlıdır. Ortalama PnL tüm katmanlarda pozitiftir. MaxDD katmanla birlikte öngörülebilir şekilde artmaktadır. Bu, gerçek bir piyasa üstünlüğüne sahip sağlam bir stratejidir. Optimizasyon sembolündeki daha mütevazı PnL'ye rağmen (+%25 vs +%55), Strateji B, Strateji A'ya kıyasla önemli ölçüde daha güvenilirdir.

Strateji C (ETHUSDT Üzerinde Optimize Edilmiş)

Parametreler: PnL +%300, ~400 işlem, ~%45 aktif süre, MaxDD ~%17.

Karar: Strateji C klasik aşırı uyumdur. ETHUSDT'de +%301, ancak diğer paritelerin büyük çoğunluğunda felaket kayıpları. Katman 3'teki MaxDD %70'i aşıyor — bu sermaye yok etme demektir. Strateji, piyasa verimsizliğini değil, ETH'nin kendine özgü kalıplarını yakalamıştır. Reddet.

Stratejiler Neden Diğer Sembollerde Bozuluyor

1. Volatilite Uyumsuzluğu

En yaygın neden. Strateji parametreleri belirli bir volatilite seviyesine göre ayarlanır. Strateji %2'lik bir giriş eşiği kullanıyorsa — %3 günlük volatiliteye sahip ETH için bu makul bir filtredir. %8 günlük volatiliteye sahip DOGE için — bu eşik çok sık tetiklenir ve çok sayıda yanlış sinyal üretir.

Benzer şekilde, %1'lik bir stop loss ETH için yeterlidir, ancak PEPE için bu normal "gürültü"dür ve stop loss günde onlarca kez tetiklenir.

2. Likidite Farklılıkları

Strateji, mevcut fiyatta anında emir gerçekleştirimi varsayar. 5 bps içinde 50 milyon $emir defteri derinliğine sahip BTCUSDT'de — bu gerçekçidir. 200 bin$ derinliğe sahip ARBUSDT'de — 10 bin $'lık emriniz fiyatı hareket ettirecek ve gerçek gerçekleştirme %0,05-0,2 daha kötü olacaktır. 500 işlem boyunca bu, yalnızca kaymalara (slippage) kaybedilen %25-100'dür.

3. Piyasa Mikro Yapısı

Her enstrümanın kendine özgü bir mikro yapısı vardır:

• Fonlama oranları: BTC'de, boğa piyasasında fonlama sürekli pozitiftir (her 8 saatte +%0,01). Meme coin'lerde, fonlama -%0,3'ten +%0,5'e atlayabilir. Daha fazla ayrıntı — Fonlama oranları kaldıraçınızı öldürüyor.
• Spread: Katman 1'de spread %0,01, Katman 4'te — %0,5. Küçük kâr hedeflerine sahip bir strateji, spread, hedef büyüklüğünü aştığında kârlı olamaz.
• Manipülasyon kalıpları: fitiller, spoofing, wash trading — her katmanda farklı biçimlerde kendini gösterir.

4. Rejim Duyarlılığı

Altcoin'ler farklı piyasa aşamalarında farklı davranır:

• Boğa trendinde, altcoin'ler BTC'yi geride bırakır (beta > 1)
• Ayı trendinde, altcoin'ler BTC'den daha sert düşer
• Yatay piyasada, altcoin'ler BTC ile korelasyon gösterebilir veya kendi anlatıları üzerinde hareket edebilir

Tek bir sembol üzerinde tek bir fazda optimize edilmiş bir strateji, özellikle o sembolün BTC'ye göre gecikmesine/önüne geçmesine optimal biçimde ayarlanmış olabilir — ve bu gecikme/öne geçme, rejim değiştiğinde değişecektir.

Uyarlamalı Parametre Ölçekleme

Tüm semboller üzerinde aynı parametrelerle bir strateji çalıştırmak yanlıştır. Ancak her sembol üzerinde tam yeniden optimizasyon, çok sembolli doğrulamanın amacını ortadan kaldırır (parametreler her sembol için "yerli" hale gelir).

Uzlaşı parametrelerin volatiliteye göre normalleştirilmesidir:

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:
    """
    Strateji parametrelerini hedef sembol volatilitesine göre ölçekle.

    Args:
        base_params: orijinal sembol üzerinde optimize edilmiş parametreler
        optimization_symbol_vol: optimizasyon sembolünün günlük volatilitesi
        target_symbol_vol: hedef sembolün günlük volatilitesi
        vol_sensitive_params: volatiliteye duyarlı parametrelerin listesi
    """
    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 — giriş eşiği
    "stop_loss": 0.01,           # %1 — stop loss
    "take_profit": 0.03,         # %3 — kâr hedefi
    "trailing_stop": 0.008,      # %0,8 — izleyen stop
    "atr_multiplier": 2.5,       # ATR çarpanı (ölçeklenmez)
    "rsi_period": 14,            # RSI periyodu (ölçeklenmez)
    "ma_fast": 10,               # hızlı MA (ölçeklenmez)
    "ma_slow": 50,               # yavaş MA (ölçeklenmez)
}

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})

Çıktı:

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'}

Stop loss %1'den %2,53'e yükseldi — DOGE'un %8,1 günlük volatilitesi için uygun. Ölçekleme olmadan, %1'lik bir stop loss günde onlarca kez "gürültü" tarafından tetiklenirdi.

Önemli: yalnızca fiyat eşiklerini ölçekleyin (girişler, stoplar, hedefler). Gösterge periyotları (RSI, MA) ve çarpanlar (ATR çarpanı) genellikle ölçeklenmez — bunlar zaten göstergenin kendisi aracılığıyla volatiliteye göre normalleştirilmiştir.

İki Doğrulama Modu

1. Katı mod (ölçekleme olmadan): aynı parametrelerle çalıştır. Mutlak sağlamlık testi. Strateji kârlıysa — üstünlük (edge) güçlüdür.

2. Uyarlamalı mod (ölçeklemeyle): normalleştirilmiş parametrelerle çalıştır. Volatilite seviyelerinin farklı olduğunu göz önünde bulundurarak strateji mantığının sağlamlık testi.

Her iki testi de çalıştırmanızı öneririz. Katı mod — üstünlüğün "gücünü" değerlendirmek için. Uyarlamalı mod — pratik uygulama için.

Çapraz Sembol Sağlamlık Puanı

Çok sembolli sağlamlığın nicel değerlendirmesi için bileşik bir metrik sunuyoruz — Cross-Symbol Robustness Score (CSRS).

Formül

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

burada:

• $R_{profit}$ — kârlı sembollerin oranı:

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

• $R_{pnl}$ — normalleştirilmiş likidite ağırlıklı ortalama PnL:

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

burada $l_i$, sembol $i$'nin likiditesidir (ortalama günlük hacim).

• $P_{consistency}$ — katmanlar arası tutarlılık bonusu:

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

• $P_{variance}$ — semboller arası yüksek PnL varyansı için ceza:

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

Varsayılan Ağırlıklar

CSRS Yorumu

Tam Uygulama: Çok Sembolli Doğrulama Pipeline'ı

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

@dataclass
class SymbolResult:
    """Tek sembol üzerinde strateji sonucu."""
    symbol: str
    tier: int
    pnl: float
    max_dd: float
    n_trades: int
    win_rate: float
    pnl_per_active_day: float
    avg_daily_volume: float  # likidite

@dataclass
class TierResult:
    """Katmana göre toplu sonuç."""
    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:
    """Tam çok sembolli doğrulama sonucu."""
    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:
    """
    Tam çok sembolli doğrulama pipeline'ı.

    Args:
        strategy_fn: strateji fonksiyonu (data, params) -> (pnl, max_dd, n_trades, win_rate, returns)
        base_params: optimization_symbol üzerinde optimize edilmiş parametreler
        optimization_symbol: optimizasyon sembolü
        data_loader: veri yükleme fonksiyonu (symbol) -> np.ndarray
        vol_sensitive_params: volatiliteye göre ölçeklenecek parametreler
        adaptive: volatilite ölçeklemesi kullan
        csrs_weights: CSRS için ağırlıklar (w1, w2, w3, w4)
        min_profit_ratio: bir katmandaki kârlı sembollerin minimum oranı
    """
    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)  # kaba tahmin
            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)  # cezayı sınırla

    csrs = w1 * r_profit + w2 * r_pnl + w3 * p_consistency - w4 * (p_variance / 5.0)
    csrs = max(0, min(1, csrs))  # [0, 1] aralığına sıkıştır

    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:
    """Metin raporu oluştur."""
    lines = []
    lines.append("=" * 60)
    lines.append("ÇOK SEMBOLLİ DOĞRULAMA RAPORU")
    lines.append(f"Optimizasyon sembolü: {opt_symbol}")
    lines.append(f"Mod: {'uyarlamalı' if adaptive else 'katı'}")
    lines.append(f"CSRS: {csrs:.3f}")
    lines.append(f"Geçti: {'EVET' if passed else 'HAYIR'}")
    lines.append("=" * 60)

    for tr in tier_results:
        lines.append(f"\n--- Katman {tr.tier} ---")
        lines.append(f"  Semboller: {tr.n_symbols}, Kârlı: {tr.n_profitable} "
                      f"({tr.profit_ratio:.0%})")
        lines.append(f"  Ort. PnL: {tr.avg_pnl:.2%}, Ort. MaxDD: {tr.avg_max_dd:.2%}")
        lines.append(f"  PnL StdSap: {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)

Pipeline Kullanım Örneği

def my_strategy(data, params):
    """Stratejiniz. (pnl, max_dd, n_trades, win_rate, returns) döndürür."""
    pass

def load_ohlcv(symbol):
    """Bir sembol için OHLCV verisi yükle."""
    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"Geçti: {result.passed}")

Tek Sembolli Doğrulamanın Kabul Edilebilir Olduğu Durumlar

Her stratejinin birden fazla enstrümanda çalışması gerekmez. Tek sembolün normal bir yaklaşım olduğu meşru durumlar vardır:

Belirli Bir Emir Defteri Üzerinde Piyasa Yapıcılığı

Bir piyasa yapıcılığı stratejisi (örneğin, Avellaneda-Stoikov modeli kullanarak) tanım gereği belirli bir emir defterine bağlıdır. Parametreler belirli mikro yapıya bağlıdır: derinlik, spread, kuyruk pozisyonu, dolum oranı. Başka bir sembol üzerinde test etmek anlamsızdır — bu farklı bir emir defteridir.

Belirli Pariteler Arası Arbitraj

Fonlama oranı arbitrajı veya borsalar arası arbitraj tanım gereği belirli enstrüman çiftlerine bağlıdır. Buradaki doğrulama, farklı semboller üzerinde değil, aynı paritelerle farklı borsalar üzerindedir.

Benzersiz Varlık Özelliklerini Açıkça Kullanan Stratejiler

Bir strateji, bir varlığın belirli bir özelliğine dayanıyorsa (örneğin, BTC'nin hashrate ile korelasyonu veya ETH'nin gas ücretleriyle korelasyonu), çok sembolli doğrulama uygulanamaz. Ancak bu tür stratejiler nadirdir.

Diğer tüm durumlarda — strateji "genel" sinyallere dayanıyorsa (MA kesişimi, RSI, momentum, ortalamaya dönüş) — çok sembolli doğrulama zorunludur. Genel bir strateji yalnızca tek bir sembolde çalışıyorsa, bu bir üstünlük değil — aşırı uyumdur.

Diğer Doğrulama Yöntemleriyle İlişki

Çok sembolli doğrulama, örneklem dışı testin üç dik yönteminden biridir:

Her yöntem kendi ekseninde sağlamlığı kontrol eder. Bir strateji walk-forward'ı geçip çok sembolliyi başaramayabilir (enstrümana eğri uydurulmuş). Çok sembolliyi geçip Monte Carlo'da başarısız olabilir (şanslı bir işlem sırasına bağlı).

Maksimum aşırı uyum koruması: üç yöntemin tamamını kullanın.

Tam doğrulama pipeline'ı:

1. Tek sembol üzerinde parametrelerin optimizasyonu
2. Plato analizi — optimum kararlılık kontrolü
3. Walk-forward — zaman ekseni doğrulaması (WFER > 0,5)
4. Çok sembolli — enstrüman ekseni doğrulaması (CSRS > 0,5)
5. Monte Carlo bootstrap — güven aralıkları (5. yüzdelik dilim > 0)
6. Fonlama oranlarını ve kayıp asimetrisini hesaba kat

Altı kontrolü de geçen bir stratejinin aşırı uyum artefaktı olma olasılığı minimumdur.

Uzantılar: Sembol Korelasyonu ve Kademeli Stratejiler

Çok sembolli doğrulama başka bir boyutu da ortaya çıkarır: semboller arası korelasyonlar. Bir strateji BTC ve ETH'de kârlı ancak tüm altcoin'lerde kârsız oluyorsa — bu, üstünlüğün yüksek BTC-ETH korelasyonuna bağlı olduğu bilgisidir. Korelasyon yapılarının ayrıntılı analizi — Sinyal korelasyonu ve çift ticareti makalesinde.

Strateji portföyleri için, çok sembolli sonuçlar bir stratejinin hangi enstrümanlarda başlatılması gerektiğini belirler. Yukarıdaki örnekteki Strateji A — yalnızca Katman 1-2. Strateji B — Katman 1-3. Bu, farklı stratejilerin sağlamlık profillerine bağlı olarak farklı enstrümanlarda başlatıldığı kademeli orkestrasyon için girdi verisidir.

Sonuç

Çok sembolli doğrulama isteğe bağlı değildir — genelleştirilmiş bir piyasa üstünlüğü iddiasında bulunan her strateji için zorunlu bir adımdır. Temel çıkarımlar:

1. Yalnızca tek bir sembolde çalışan bir strateji büyük ihtimalle o sembolün özelliklerine aşırı uyumludur. İstisnalar: piyasa yapıcılığı, arbitraj, benzersiz varlık özelliklerine dayanan stratejiler.

2. Katman gruplandırması zorunludur. Volatilite, likidite ve mikro yapıdaki farklılıkları anlamadan BTC (Katman 1) üzerindeki sonuçları PEPE (Katman 3) üzerindeki sonuçlarla karşılaştıramazsınız.

3. Uyarlamalı parametre ölçekleme — volatiliteye göre eşik normalleştirmesi — çok sembolli testin gerçekçiliğini önemli ölçüde artırır.

4. CSRS > 0,5 — makul bir minimum eşik. Strateji, aynı katmandaki sembollerin >= %60'ında kârlı olmalı ve tüm semboller genelindeki ortalama PnL pozitif olmalıdır.

5. Walk-forward + Çok sembolli + Monte Carlo — üç dik doğrulama ekseni. Her yöntem, diğerlerinin kaçırdığını yakalar. Üçünü de kullanın.

PnL +%25 ve CSRS 0,72 olan bir strateji, PnL +%300 ve CSRS 0,18 olan bir stratejiden daha güvenilirdir. Birincisi piyasa verimsizliğinden kazanır. İkincisi tek bir fiyat serisini ezberlemekten kazanır.

Faydalı Bağlantılar

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

Atıf

@article{soloviov2026multisymbolvalidation,
  author = {Soloviov, Eugen},
  title = {Multi-Symbol Validation: Test Your Strategy on All Pairs},
  year = {2026},
  url = {https://marketmaker.cc/tr/blog/post/multi-symbol-validation},
  version = {0.1.0},
  description = {ETHUSDT üzerinde optimize edilmiş bir strateji neden altcoinlerde başarısız olabilir. Parite grupları (blue chip'ler, büyük cap'ler, shitcoin'ler) genelinde nasıl doğru test yapılır ve çapraz sembol sağlamlık puanının yeterli sayılması için ne kadar olması gerekir.}
}