मल्टी-सिंबल वैलिडेशन: अपनी स्ट्रैटेजी को सभी पेयर्स पर टेस्ट करें

"बिना भ्रम के बैकटेस्ट" सीरीज़ का लेख

आपने ETHUSDT पर एक स्ट्रैटेजी ऑप्टिमाइज़ की। 25 महीनों का डेटा, 12+ पैरामीटर्स। बैकटेस्ट PnL +55%, 500 ट्रेड्स, MaxDD -0.9%, पोज़िशन 15% समय ओपन दिखाता है। इक्विटी कर्व सुचारू रूप से ऊपर जाता है। पैरामीटर्स ने प्लेटो एनालिसिस पास कर लिया है — ऑप्टिमम व्यापक दिखता है। वॉक-फॉरवर्ड से WFER > 0.6 मिलता है। मोंटे कार्लो बूटस्ट्रैप पॉज़िटिव 5वां पर्सेंटाइल दिखाता है।

सब कुछ परफेक्ट है। सिवाय एक चीज़ के: आपने स्ट्रैटेजी को सिर्फ एक इंस्ट्रूमेंट पर टेस्ट किया।

आप उसी एल्गोरिद्म को उन्हीं पैरामीटर्स के साथ BTCUSDT पर चलाते हैं — PnL +8%। SOLUSDT पर — PnL -12%। DOGEUSDT पर — PnL -34%। जो स्ट्रैटेजी ETH पर सभी चेक्स पास कर गई, वह ज़्यादातर बाकी पेयर्स पर अनप्रॉफिटेबल निकलती है।

यह कोई बग नहीं है। यह सिंगल-सिंबल ट्रैप है — एल्गोट्रेडिंग में ओवरफिटिंग के सबसे आम और छिपे हुए रूपों में से एक।

एकल इंस्ट्रूमेंट का ट्रैप

किसी एक सिंबल पर स्ट्रैटेजी को ऑप्टिमाइज़ करना अनिवार्यतः उसे किसी विशेष एसेट की प्राइस डायनामिक्स के अनुरूप फिट करना है। भले ही आपने वॉक-फॉरवर्ड चलाया हो, भले ही बूटस्ट्रैप व्यापक कॉन्फिडेंस इंटरवल्स दिखाए — ये सभी चेक्स एक ही टाइम सीरीज़ के भीतर किए गए थे।

वॉक-फॉरवर्ड समय के अनुसार रोबस्टनेस चेक करता है: क्या पैरामीटर्स उसी इंस्ट्रूमेंट के भविष्य के डेटा पर काम करते हैं। मोंटे कार्लो ट्रेड ऑर्डर के अनुसार रोबस्टनेस चेक करता है: क्या स्ट्रैटेजी अलग सीक्वेंस झेल सकती है। लेकिन इनमें से कोई भी मेथड इंस्ट्रूमेंट्स के अनुसार रोबस्टनेस चेक नहीं करता: क्या स्ट्रैटेजी अलग विशेषताओं वाले दूसरे एसेट्स पर काम करती है।

अगर कोई स्ट्रैटेजी सिर्फ ETHUSDT पर प्रॉफिटेबल है — तो उसने मार्केट इनएफिशिएंसी नहीं, बल्कि ETH की प्राइस सीरीज़ की विशिष्ट संरचना को कैप्चर किया है:

• ETH के लिए यूनीक कैंडलस्टिक पैटर्न
• विशिष्ट वोलैटिलिटी लेवल्स जिनके अनुसार थ्रेशोल्ड्स ट्यून किए गए हैं
• इसी खास पेयर की लिक्विडिटी और माइक्रोस्ट्रक्चर की विशेषताएं
• BTC के साथ करेलेशन, जो किसी खास पीरियड की विशेषता है

इनमें से कुछ भी एज नहीं है। यह इंस्ट्रूमेंट लेवल पर कर्व फिटिंग है।

क्रिप्टो मार्केट में सिंबल ग्रुप्स (टियर्स)

सभी क्रिप्टोकरेंसीज़ बराबर नहीं होतीं। सार्थक मल्टी-सिंबल वैलिडेशन के लिए, आपको यह समझना होगा कि इंस्ट्रूमेंट्स को मौलिक रूप से अलग विशेषताओं वाले ग्रुप्स में बांटा जाता है।

टियर 1: ब्लू चिप्स (BTC, ETH)

उच्च लिक्विडिटी, अपेक्षाकृत कम वोलैटिलिटी, इंस्टीट्यूशनल फ्लो। मैक्रो (S&P 500, DXY, फेड रेट्स) के साथ करेलेशन। गहरे ऑर्डर बुक्स, टाइट स्प्रेड्स, स्थिर फंडिंग रेट्स। सामान्य दैनिक वोलैटिलिटी: 2-4%।

टियर 2: लार्ज कैप्स (SOL, BNB, ADA, XRP, AVAX)

मध्यम लिक्विडिटी, बढ़ी हुई वोलैटिलिटी। मूवमेंट्स अक्सर सेक्टर डायनामिक्स (L1 बनाम L2, DeFi बनाम इन्फ्रा) से प्रेरित होते हैं। फंडिंग रेट्स ज़्यादा वोलैटाइल होते हैं। स्प्रेड्स ज़्यादा चौड़े होते हैं। सामान्य दैनिक वोलैटिलिटी: 4-6%।

टियर 3: मिड कैप्स (DOGE, SHIB, PEPE, ARB, OP)

मीम कॉइन्स और नैरेटिव टोकन। उच्च वोलैटिलिटी, फंडामेंटल फैक्टर्स के साथ कम करेलेशन। मूवमेंट्स सोशल मीडिया, लिस्टिंग्स, नैरेटिव्स से तय होते हैं। कुछ एक्सचेंजों पर पतले ऑर्डर बुक्स। सामान्य दैनिक वोलैटिलिटी: 6-10%।

टियर 4: लो कैप्स (नई लिस्टिंग्स)

एक्सट्रीम वोलैटिलिटी, पतले ऑर्डर बुक्स, मैनिपुलेशन का जोखिम। अक्सर पूर्ण बैकटेस्ट के लिए अपर्याप्त हिस्ट्री। सामान्य दैनिक वोलैटिलिटी: 10-20%+।

विशेषताओं की सारांश तालिका

हर टियर अपनी माइक्रोस्ट्रक्चर के साथ एक अलग "दुनिया" है। टियर 1 के लिए ट्यून की गई स्ट्रैटेजी टियर 3 में जाने पर एक अनजान माहौल में प्रवेश करती है।

मल्टी-सिंबल वैलिडेशन की मेथडोलॉजी

चरण 1: एक सिंगल सिंबल पर ऑप्टिमाइज़ करें

ऑप्टिमाइज़ेशन के लिए एक सिंबल चुनें — उदाहरण के लिए ETHUSDT। पूरी पाइपलाइन चलाएं: Optuna ऑप्टिमाइज़ेशन, प्लेटो एनालिसिस, वॉक-फॉरवर्ड। पैरामीटर्स को फिक्स करें।

चरण 2: उसी टियर के सिंबल्स पर टेस्ट करें

उन्हीं पैरामीटर्स के साथ स्ट्रैटेजी को उसी टियर के 5-10 सिंबल्स पर चलाएं। टियर 1 के लिए यह सीमित है (BTC + ETH), लेकिन टियर 2 और टियर 3 के लिए पर्याप्त सिंबल्स हैं।

चरण 3: अन्य टियर्स के सिंबल्स पर टेस्ट करें

स्ट्रैटेजी को हर दूसरे टियर के 3-5 सिंबल्स पर चलाएं। यह सबसे कठिन टेस्ट है: अगर स्ट्रैटेजी ETHUSDT (टियर 1) और DOGEUSDT (टियर 3) दोनों पर काम करती है, तो कर्व फिटिंग की संभावना न्यूनतम है।

चरण 4: ग्रुप के अनुसार परिणामों का विश्लेषण करें

टियर के अनुसार मेट्रिक्स को एग्रीगेट करें और क्रॉस-सिंबल रोबस्टनेस का मूल्यांकन करें।

हर सिंबल के लिए मेट्रिक्स

हर सिंबल के लिए रिकॉर्ड करें:

• PnL — कुल रिटर्न
• MaxDD — अधिकतम ड्रॉडाउन
• N trades — ट्रेड्स की संख्या
• Win rate — प्रॉफिटेबल ट्रेड्स का अनुपात
• PnL/एक्टिव दिन — एक्टिव टाइम की प्रति यूनिट रिटर्न (अधिक जानकारी एक्टिव टाइम के अनुसार PnL में)

पास होने के मानदंड

स्ट्रैटेजी मल्टी-सिंबल वैलिडेशन पास करती है अगर:

1. समान टियर के >= 60% सिंबल्स पर प्रॉफिटेबल हो
2. ग्रुप में औसत PnL पॉज़िटिव हो
3. MaxDD नाटकीय रूप से न बढ़े (ऑप्टिमाइज़ेशन सिंबल की तुलना में 2-3x से ज़्यादा नहीं)
4. अगर स्ट्रैटेजी सिर्फ ऑप्टिमाइज़ेशन सिंबल पर ही प्रॉफिटेबल है — रिजेक्ट करें

उदाहरण: तीन स्ट्रैटेजीज़, तीन परिणाम

आइए एक ठोस उदाहरण देखते हैं। तीन स्ट्रैटेजीज़ (स्ट्रैटेजी A, स्ट्रैटेजी B, स्ट्रैटेजी C), ETHUSDT पर ऑप्टिमाइज़्ड, चार टियर्स के 12 सिंबल्स पर टेस्टेड।

स्ट्रैटेजी A (ETHUSDT पर ऑप्टिमाइज़्ड)

पैरामीटर्स: PnL +55%, ~500 ट्रेड्स, ~15% एक्टिव टाइम, MaxDD ~0.9%।

* — ऑप्टिमाइज़ेशन सिंबल

टियर के अनुसार परिणाम:

निष्कर्ष: स्ट्रैटेजी A टियर 1-2 पर काम करती है लेकिन टियर 3 पर पूरी तरह फेल हो जाती है। यह कम वोलैटिलिटी वाले माहौल के लिए ट्यून की गई एक विशिष्ट स्ट्रैटेजी है। ब्लू चिप्स और लार्ज कैप्स के पोर्टफोलियो के लिए — स्वीकार्य। यूनिवर्सल उपयोग के लिए — नहीं।

स्ट्रैटेजी B (ETHUSDT पर ऑप्टिमाइज़्ड)

पैरामीटर्स: PnL +25%, ~40 ट्रेड्स, ~5% एक्टिव टाइम।

टियर के अनुसार परिणाम:

निष्कर्ष: स्ट्रैटेजी B 11 में से 9 सिंबल्स (82%) पर प्रॉफिटेबल है। सभी टियर्स में औसत PnL पॉज़िटिव है। MaxDD टियर के अनुसार अनुमानित रूप से बढ़ता है। यह असली मार्केट एज वाली एक रोबस्ट स्ट्रैटेजी है। ऑप्टिमाइज़ेशन सिंबल पर ज़्यादा मामूली PnL (+25% बनाम +55%) के बावजूद, स्ट्रैटेजी B स्ट्रैटेजी A की तुलना में काफी ज़्यादा भरोसेमंद है।

स्ट्रैटेजी C (ETHUSDT पर ऑप्टिमाइज़्ड)

पैरामीटर्स: PnL +300%, ~400 ट्रेड्स, ~45% एक्टिव टाइम, MaxDD ~17%।

निष्कर्ष: स्ट्रैटेजी C क्लासिक ओवरफिटिंग है। ETHUSDT पर +301%, लेकिन ज़्यादातर बाकी पेयर्स पर विनाशकारी नुकसान। टियर 3 पर MaxDD 70% से ज़्यादा है — यह कैपिटल का विनाश है। स्ट्रैटेजी ने ETH के यूनीक पैटर्न कैप्चर किए, कोई मार्केट इनएफिशिएंसी नहीं। रिजेक्ट।

स्ट्रैटेजीज़ दूसरे सिंबल्स पर क्यों टूटती हैं

1. वोलैटिलिटी मिसमैच

सबसे आम कारण। स्ट्रैटेजी के पैरामीटर्स किसी खास वोलैटिलिटी लेवल के अनुसार ट्यून किए गए हैं। अगर स्ट्रैटेजी 2% एंट्री थ्रेशोल्ड इस्तेमाल करती है — तो 3% दैनिक वोलैटिलिटी वाले ETH के लिए यह एक उचित फिल्टर है। 8% दैनिक वोलैटिलिटी वाले DOGE के लिए यह थ्रेशोल्ड बहुत ज़्यादा बार ट्रिगर होता है, जिससे बहुत सारे झूठे सिग्नल पैदा होते हैं।

इसी तरह, 1% स्टॉप लॉस ETH के लिए उपयुक्त है, लेकिन PEPE के लिए यह सामान्य "नॉइज़" है, और स्टॉप दिन में दर्जनों बार हिट होता है।

2. लिक्विडिटी में अंतर

स्ट्रैटेजी यह मानती है कि ऑर्डर मौजूदा कीमत पर तुरंत एग्ज़िक्यूट हो जाएगा। $50M ऑर्डर बुक डेप्थ वाले BTCUSDT पर 5 bps के भीतर — यह यथार्थवादी है।$200K डेप्थ वाले ARBUSDT पर — आपका $10K ऑर्डर कीमत को हिला देगा, और वास्तविक एग्ज़िक्यूशन 0.05-0.2% बदतर होगा। 500 ट्रेड्स में, सिर्फ स्लिपेज से 25-100% नुकसान होता है।

3. मार्केट माइक्रोस्ट्रक्चर

हर इंस्ट्रूमेंट की अपनी माइक्रोस्ट्रक्चर होती है:

• फंडिंग रेट्स: BTC पर, बुल मार्केट में फंडिंग लगातार पॉज़िटिव रहता है (हर 8 घंटे में +0.01%)। मीम कॉइन्स पर, फंडिंग -0.3% से +0.5% तक उछल सकता है। ज़्यादा जानकारी फंडिंग रेट्स आपके लीवरेज को खा जाते हैं में।
• स्प्रेड: टियर 1 पर स्प्रेड 0.01% है, टियर 4 पर — 0.5%। छोटे टेक-प्रॉफिट्स वाली स्ट्रैटेजी प्रॉफिटेबल नहीं हो सकती जब स्प्रेड टेक साइज़ से ज़्यादा हो।
• मैनिपुलेशन पैटर्न्स: विक्स, स्पूफिंग, वॉश ट्रेडिंग — हर टियर पर अलग तरह से दिखाई देते हैं।

4. रेजीम सेंसिटिविटी

अलग-अलग मार्केट फेज़ में ऑल्टकॉइन्स अलग तरह से बर्ताव करते हैं:

• बुल ट्रेंड में, ऑल्टकॉइन्स BTC को आउटपरफॉर्म करते हैं (बीटा > 1)
• बेयर ट्रेंड में, ऑल्टकॉइन्स BTC से ज़्यादा गिरते हैं
• साइडवेज़ मार्केट में, ऑल्टकॉइन्स या तो BTC के साथ करेलेट कर सकते हैं या अपनी नैरेटिव्स के हिसाब से मूव कर सकते हैं

किसी एक फेज़ में किसी एक सिंबल पर ऑप्टिमाइज़्ड स्ट्रैटेजी उस सिंबल के BTC के सापेक्ष लैग/लीड के लिए ऑप्टिमली ट्यून हो सकती है — और रेजीम बदलने पर यह लैग/लीड बदल जाएगा।

एडैप्टिव पैरामीटर स्केलिंग

सभी सिंबल्स पर समान पैरामीटर्स के साथ स्ट्रैटेजी चलाना गलत है। लेकिन हर सिंबल पर पूर्ण री-ऑप्टिमाइज़ेशन मल्टी-सिंबल वैलिडेशन के मूल उद्देश्य को ही नाकाम कर देता है (पैरामीटर्स हर सिंबल के लिए "नेटिव" हो जाते हैं)।

समझौता है वोलैटिलिटी के अनुसार पैरामीटर नॉर्मलाइज़ेशन:

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

# Example: Strategy A, optimized on ETHUSDT
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)
}

# Parameters that need scaling
vol_sensitive = ["entry_threshold", "stop_loss", "take_profit", "trailing_stop"]

# Volatilities (daily)
eth_vol = 0.032     # 3.2%
doge_vol = 0.081    # 8.1%

# Scale for DOGE
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})

आउटपुट:

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

स्टॉप लॉस 1% से बढ़कर 2.53% हो गया — जो DOGE की 8.1% दैनिक वोलैटिलिटी के लिए उपयुक्त है। स्केलिंग के बिना, 1% का स्टॉप "नॉइज़" से दर्जनों बार हिट हो जाता।

महत्वपूर्ण: सिर्फ प्राइस थ्रेशोल्ड्स (एंट्रीज़, स्टॉप्स, टेक्स) को स्केल करें। इंडिकेटर पीरियड्स (RSI, MA) और मल्टीप्लायर्स (ATR मल्टीप्लायर) आमतौर पर स्केल नहीं किए जाते — वे पहले से ही इंडिकेटर के ज़रिए वोलैटिलिटी के अनुसार नॉर्मलाइज़्ड होते हैं।

दो वैलिडेशन मोड्स

1. स्ट्रिक्ट मोड (बिना स्केलिंग): समान पैरामीटर्स के साथ चलाना। एब्सोल्यूट रोबस्टनेस का टेस्ट। अगर स्ट्रैटेजी प्रॉफिटेबल है — तो एज मज़बूत है।

2. एडैप्टिव मोड (स्केलिंग के साथ): नॉर्मलाइज़्ड पैरामीटर्स के साथ चलाना। स्ट्रैटेजी लॉजिक की रोबस्टनेस का टेस्ट, इस बात को मानते हुए कि वोलैटिलिटी लेवल्स अलग-अलग होते हैं।

हम दोनों टेस्ट्स चलाने की सलाह देते हैं। स्ट्रिक्ट मोड — एज की "ताकत" का आकलन करने के लिए। एडैप्टिव मोड — प्रैक्टिकल उपयोग के लिए।

क्रॉस-सिंबल रोबस्टनेस स्कोर

मल्टी-सिंबल रोबस्टनेस के क्वांटिटेटिव मूल्यांकन के लिए, हम एक कंपोज़िट मेट्रिक पेश करते हैं — क्रॉस-सिंबल रोबस्टनेस स्कोर (CSRS)।

फॉर्मूला

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

जहां:

• $R_{profit}$ — प्रॉफिटेबल सिंबल्स का अनुपात:

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

• $R_{pnl}$ — नॉर्मलाइज़्ड लिक्विडिटी-वेटेड औसत PnL:

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

जहां $l_i$ सिंबल $i$ की लिक्विडिटी है (औसत दैनिक वॉल्यूम)।

• $P_{consistency}$ — क्रॉस-टियर कंसिस्टेंसी के लिए बोनस:

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

• $P_{variance}$ — सिंबल्स के बीच उच्च PnL वेरिएंस के लिए पेनल्टी:

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

डिफॉल्ट वेट्स

CSRS की व्याख्या

पूर्ण इम्प्लीमेंटेशन: मल्टी-सिंबल वैलिडेशन पाइपलाइन

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 dictionary by tier
SYMBOL_TIERS = {
    1: ["BTCUSDT", "ETHUSDT"],
    2: ["SOLUSDT", "BNBUSDT", "ADAUSDT", "XRPUSDT", "AVAXUSDT"],
    3: ["DOGEUSDT", "SHIBUSDT", "PEPEUSDT", "ARBUSDT", "OPUSDT"],
}

# Approximate daily volatilities
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,
}

# Approximate average daily volumes ($)
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 = []

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

            # Parameter scaling
            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()

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

            # PnL per active day (simplified)
            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),
            ))

    # Aggregation by tier
    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),
        ))

    # Compute CSRS
    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
    r_profit = n_profitable / n_total if n_total > 0 else 0

    # R_pnl (liquidity-weighted)
    total_vol = sum(all_volumes)
    r_pnl_raw = sum(r.pnl * r.avg_daily_volume for r in symbol_results) / total_vol
    # Normalize to [0, 1]: using sigmoid
    r_pnl = 1 / (1 + np.exp(-r_pnl_raw * 5))

    # P_consistency
    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

    # P_variance
    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]

    # Pass criteria
    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
    )

    # Generate report
    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)

    # By tier
    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)

पाइपलाइन उपयोग उदाहरण

# Assume you have a strategy function and data loader
def my_strategy(data, params):
    """Your strategy. Returns (pnl, max_dd, n_trades, win_rate, returns)."""
    # ... implementation ...
    pass

def load_ohlcv(symbol):
    """Load OHLCV data for a symbol."""
    # ... load from database / API ...
    pass

# Parameters optimized on ETHUSDT
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,
}

# Run validation
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}")

सिंगल-सिंबल वैलिडेशन कब स्वीकार्य है

हर स्ट्रैटेजी को कई इंस्ट्रूमेंट्स पर काम करना ज़रूरी नहीं है। ऐसे वैध मामले हैं जहां सिंगल-सिंबल एक सामान्य अप्रोच है:

किसी विशिष्ट ऑर्डर बुक पर मार्केट मेकिंग

मार्केट-मेकिंग स्ट्रैटेजी (जैसे Avellaneda-Stoikov मॉडल का उपयोग करते हुए) परिभाषा के अनुसार एक विशिष्ट ऑर्डर बुक से बंधी होती है। पैरामीटर्स विशिष्ट माइक्रोस्ट्रक्चर पर निर्भर करते हैं: डेप्थ, स्प्रेड, क्यू पोज़िशन, फिल रेट। किसी अन्य सिंबल पर टेस्ट करना निरर्थक है — यह एक अलग ऑर्डर बुक है।

विशिष्ट पेयर्स के बीच आर्बिट्राज

फंडिंग रेट आर्बिट्राज या क्रॉस-एक्सचेंज आर्बिट्राज परिभाषा के अनुसार विशिष्ट इंस्ट्रूमेंट पेयर्स से बंधे होते हैं। यहां वैलिडेशन उन्हीं पेयर्स के साथ दूसरे एक्सचेंजों पर होता है, अलग सिंबल्स पर नहीं।

स्ट्रैटेजीज़ जो स्पष्ट रूप से एसेट की यूनीक प्रॉपर्टीज़ का उपयोग करती हैं

अगर कोई स्ट्रैटेजी किसी एसेट की किसी विशिष्ट प्रॉपर्टी पर आधारित है (जैसे BTC का हैशरेट के साथ करेलेशन या ETH का गैस फीस के साथ करेलेशन), तो मल्टी-सिंबल वैलिडेशन लागू नहीं होती। लेकिन ऐसी स्ट्रैटेजीज़ दुर्लभ हैं।

बाकी सभी मामलों में — अगर स्ट्रैटेजी "जेनेरिक" सिग्नल्स (MA क्रॉसओवर, RSI, मोमेंटम, मीन रिवर्ज़न) पर आधारित है — मल्टी-सिंबल वैलिडेशन अनिवार्य है। अगर कोई जेनेरिक स्ट्रैटेजी सिर्फ एक सिंबल पर काम करती है, तो यह एज नहीं है — यह ओवरफिटिंग है।

अन्य वैलिडेशन मेथड्स के साथ संबंध

मल्टी-सिंबल वैलिडेशन आउट-ऑफ-सैंपल टेस्टिंग की तीन ऑर्थोगोनल मेथड्स में से एक है:

हर मेथड अपने ही एक्सिस के अनुसार रोबस्टनेस चेक करता है। कोई स्ट्रैटेजी वॉक-फॉरवर्ड पास कर सकती है लेकिन मल्टी-सिंबल में फेल हो सकती है (इंस्ट्रूमेंट पर कर्व फिटिंग)। यह मल्टी-सिंबल पास कर सकती है लेकिन मोंटे कार्लो में फेल हो सकती है (किसी भाग्यशाली ट्रेड ऑर्डर पर निर्भर होने के कारण)।

ओवरफिटिंग से अधिकतम सुरक्षा: तीनों मेथड्स का उपयोग करें।

पूर्ण वैलिडेशन पाइपलाइन:

1. एक सिंगल सिंबल पर पैरामीटर्स का ऑप्टिमाइज़ेशन
2. प्लेटो एनालिसिस — ऑप्टिमम स्टेबिलिटी चेक
3. वॉक-फॉरवर्ड — टाइम-एक्सिस वैलिडेशन (WFER > 0.5)
4. मल्टी-सिंबल — इंस्ट्रूमेंट-एक्सिस वैलिडेशन (CSRS > 0.5)
5. मोंटे कार्लो बूटस्ट्रैप — कॉन्फिडेंस इंटरवल्स (5वां पर्सेंटाइल > 0)
6. फंडिंग रेट्स और लॉस-प्रॉफिट असिमेट्री का ध्यान रखें

जो स्ट्रैटेजी सभी छह चेक्स पास करती है, उसके ओवरफिटिंग आर्टिफैक्ट होने की संभावना न्यूनतम होती है।

विस्तार: सिंबल करेलेशन और कैस्केड स्ट्रैटेजीज़

मल्टी-सिंबल वैलिडेशन एक और पहलू उजागर करता है: सिंबल्स के बीच करेलेशन। अगर कोई स्ट्रैटेजी BTC और ETH पर प्रॉफिटेबल है लेकिन सभी ऑल्टकॉइन्स पर अनप्रॉफिटेबल है — तो यह इस बात की जानकारी है कि एज BTC-ETH के उच्च करेलेशन से बंधा है। करेलेशन स्ट्रक्चर्स का विस्तृत विश्लेषण लेख सिग्नल करेलेशन और पेयर्स ट्रेडिंग में है।

स्ट्रैटेजी पोर्टफोलियोज़ के लिए, मल्टी-सिंबल परिणाम यह तय करते हैं कि किन इंस्ट्रूमेंट्स पर स्ट्रैटेजी लॉन्च की जानी चाहिए। ऊपर के उदाहरण की स्ट्रैटेजी A — सिर्फ टियर 1-2। स्ट्रैटेजी B — टियर 1-3। यह कैस्केड ऑर्केस्ट्रेशन के लिए इनपुट डेटा है, जहां अलग-अलग स्ट्रैटेजीज़ को उनकी रोबस्टनेस प्रोफाइल के आधार पर अलग-अलग इंस्ट्रूमेंट्स पर लॉन्च किया जाता है।

निष्कर्ष

मल्टी-सिंबल वैलिडेशन वैकल्पिक नहीं है — यह किसी भी स्ट्रैटेजी के लिए एक अनिवार्य कदम है जो एक जनरलाइज़्ड मार्केट एज का दावा करती है। मुख्य बिंदु:

1. जो स्ट्रैटेजी सिर्फ एक सिंबल पर काम करती है, वह सबसे ज़्यादा संभावना है कि उस सिंबल की विशेषताओं पर ओवरफिट है। अपवाद: मार्केट मेकिंग, आर्बिट्राज, एसेट की यूनीक प्रॉपर्टीज़ पर आधारित स्ट्रैटेजीज़।

2. टियर ग्रुपिंग अनिवार्य है। वोलैटिलिटी, लिक्विडिटी और माइक्रोस्ट्रक्चर के अंतर को समझे बिना आप BTC (टियर 1) के परिणामों की तुलना PEPE (टियर 3) के परिणामों से नहीं कर सकते।

3. एडैप्टिव पैरामीटर स्केलिंग — वोलैटिलिटी के अनुसार थ्रेशोल्ड नॉर्मलाइज़ेशन — मल्टी-सिंबल टेस्टिंग के यथार्थवाद को काफी बेहतर बनाता है।

4. CSRS > 0.5 — एक उचित न्यूनतम थ्रेशोल्ड। स्ट्रैटेजी को उसी टियर के >= 60% सिंबल्स पर प्रॉफिटेबल होना चाहिए, और सभी सिंबल्स में औसत PnL पॉज़िटिव होना चाहिए।

5. वॉक-फॉरवर्ड + मल्टी-सिंबल + मोंटे कार्लो — तीन ऑर्थोगोनल वैलिडेशन एक्सिस। हर मेथड वह पकड़ता है जो बाकी छोड़ देते हैं। तीनों का उपयोग करें।

+25% PnL और 0.72 CSRS वाली स्ट्रैटेजी +300% PnL और 0.18 CSRS वाली स्ट्रैटेजी से ज़्यादा भरोसेमंद है। पहली मार्केट इनएफिशिएंसी से कमाती है। दूसरी एक सिंगल प्राइस सीरीज़ को याद रखकर कमाती है।

---

उपयोगी लिंक्स

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

उद्धरण

@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.}
}