रैंडम बनाम स्मार्ट सर्च: क्रॉसओवर इवैल कॉस्ट से तय होता है, एल्गोरिदम से नहीं

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

हाइपरपैरामीटर ऑप्टिमाइजेशन में एक प्रचलित धारणा है: रैंडम सर्च वह बेसलाइन है जिसे आप आगे बढ़कर पीछे छोड़ देते हैं। Bergstra और Bengio के क्लासिक नतीजे (2012) ने स्थापित किया कि रैंडम, ग्रिड को मात देता है; उसके बाद बायेसियन ऑप्टिमाइजेशन, TPE, CMA-ES, और Hyperband/ASHA जैसी मल्टी-फिडेलिटी विधियों से उम्मीद थी कि वे बारी-बारी से रैंडम को मात देंगी। तो जब हम अपने खुद के ट्रेडिंग इंजन के लिए पैरामीटर-सर्च विधियों को बेंचमार्क करने बैठे, तो हमें वही सामान्य सीढ़ी की उम्मीद थी: नीचे रैंडम, ऊपर एक स्मार्ट सैंपलर।

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

सबक यह नहीं है कि "रैंडम को कम आंका जाता है" या "बायेसियन को ज़्यादा आंका जाता है।" सबक यह है कि रैंडम और स्मार्ट सर्च के बीच का क्रॉसओवर इवैल्यूएशन कॉस्ट से तय होता है, एल्गोरिदम की चतुराई से नहीं। अपना ऑप्टिमाइज़र इस आधार पर चुनें कि एक बैकटेस्ट की कीमत कितनी है, न कि उसकी प्रतिष्ठा के आधार पर। यह लेख ठीक-ठीक मापता है कि क्रॉसओवर कहां बैठता है, यह वहां क्यों बैठता है, और एक पूर्वशर्त — फिडेलिटी — जो तय करती है कि महंगे-रीजीम की तरकीबें (early stopping, multi-fidelity pruning) इस्तेमाल करने के लिए सुरक्षित हैं भी या नहीं।

नीचे दी गई हर चीज़ हमारे बैकटेस्टर की दो स्क्रिप्ट्स से है: सस्ते सिंगल-टाइमफ्रेम रीजीम के लिए bench_search.py (v4, commit ee092f1), और महंगे मल्टी-टाइमफ्रेम रीजीम के लिए bench_search_multitf.py (commit 102853c)। दोनों लीक-फ्री हैं — बार i के क्लोज पर निर्णय, open[i+1] पर फिल — और दोनों हर विधि को एक मल्टी-फोल्ड रोलिंग walk-forward ऑब्जेक्टिव पर स्कोर करते हैं, एक होल्ड-आउट टेस्ट विंडो के साथ जिसे सर्च कभी नहीं देखता।

सवाल: थ्रूपुट या सैंपल-एफिशिएंसी?

हर सर्च विधि अपना वॉल-क्लॉक बजट दो चीज़ों पर खर्च करती है: यह तय करना कि आगे कहां सैंपल किया जाए (सैंपलर का अपना कंप्यूट) और सैंपल को इवैल्यूएट करना (बैकटेस्ट चलाना)। पहले को ask/tell कॉस्ट और दूसरे को इवैल कॉस्ट कहते हैं। एक तय वॉल-क्लॉक बजट पर किसी विधि की प्रभावी सर्च शक्ति, मोटे तौर पर, यह है:

$\text{points explored} \;\approx\; \frac{\text{wall-clock budget}}{\text{ask/tell cost} + \text{eval cost}}$

और इसकी अंतिम गुणवत्ता यह गिनती है गुणा इस बात से कि हर पॉइंट कितना अच्छी तरह रखा गया है। दो नॉब्स, एक-दूसरे के विरुद्ध खींचते हुए:

• थ्रूपुट — प्रति सेकंड पॉइंट्स। डम्ब सैंपलर (random, scrambled Sobol/QMC) की ask/tell कॉस्ट लगभग शून्य होती है: वे एक low-discrepancy पॉइंट जारी करते हैं और आगे बढ़ जाते हैं। वे गिनती को अधिकतम करते हैं।
• सैंपल-एफिशिएंसी — प्रति पॉइंट गुणवत्ता। स्मार्ट सैंपलर (TPE, CMA-ES, ASHA) हर पॉइंट को बेहतर तरीके से रखने के लिए ऑब्जेक्टिव को मॉडल करने में असली कंप्यूट खर्च करते हैं। वे थ्रूपुट की कीमत पर प्लेसमेंट को अधिकतम करते हैं।

कौन सा नॉब जीतता है यह पूरी तरह भाजक पर निर्भर करता है। जब इवैल कॉस्ट बहुत छोटी होती है, तो ask/tell कॉस्ट भाजक पर हावी रहती है, इसलिए जो भी चीज़ इसे बढ़ाती है — एक सरोगेट मॉडल, एक kernel density estimate, एक covariance update — वह सीधे उन पॉइंट्स की संख्या घटा देती है जिन्हें आप एक्सप्लोर करते हैं। जब इवैल कॉस्ट बड़ी होती है, तो ask/tell कॉस्ट एक राउंडिंग एरर बनकर रह जाती है, इसलिए स्मार्टनेस लगभग मुफ्त हो जाती है और आपको जितना हो सके उतना खरीद लेना चाहिए।

पूरी थीसिस एक वाक्य में यही है: ask/tell टैक्स तय है, लेकिन इसका महत्व उस इवैल कॉस्ट से तय होता है जिससे इसे विभाजित किया जाता है। अब चलिए देखते हैं कि यह होता कैसे है।

सस्ता रीजीम: डम्ब Sobol थ्रूपुट पर जीतता है

हमारी सिंगल-टाइमफ्रेम स्ट्रैटेजी 7-पैरामीटर स्पेस पर एक लीक-फ्री HMA/HMA3 सेपरेशन रूल है, जिसे एक इन-प्रोसेस numba eval_batch से इवैल्यूएट किया जाता है जो बिना किसी इंटर-प्रोसेस ओवरहेड के कॉन्फ़िगरेशंस पर prange चलाता है। इस इंजन पर, एक बैकटेस्ट लगभग मुफ्त है — रॉ कर्नेल लगभग 3–4k cfg/s की दर से कॉन्फ़िग्स इवैल्यूएट करता है। यह सस्ता रीजीम है, और यहीं ट्रेडिंग उस डीप-लर्निंग सेटिंग से साफ अलग हो जाती है जहां से ज़्यादातर HPO लोककथाएं आती हैं: हमारा "ऑब्जेक्टिव फंक्शन" 6 घंटे का GPU ट्रेनिंग रन नहीं है, यह एक 0.3-मिलीसेकंड ऐरे पास है।

हमने हर विधि को समान बजट दिया — 1,500 इवैल्यूएशन — और यह रिकॉर्ड किया कि हर एक को वे इवैल खर्च करने में कितना वॉल-क्लॉक लगा, साथ ही उसे मिला होल्ड-आउट टेस्ट ऑब्जेक्टिव भी। चूंकि इवैल बजट तय है, वॉल-क्लॉक कॉलम हर सैंपलर के ओवरहेड का सीधा माप है:

TEST वह walk-forward ऑब्जेक्टिव है (annualized PnL-per-active-time × trade-count confidence) जो एक होल्ड-आउट विंडो पर मापा गया है जिसे सर्च ने कभी नहीं छुआ; ज़्यादा बेहतर है।

दो तथ्य उभर कर सामने आते हैं। पहला, थ्रूपुट कॉलम देखें। Scrambled Sobol ~2,830 cfg/s पर चलता है — इंजन की सीलिंग के करीब। TPE ~154 cfg/s पर चलता है और ASHA ~95 पर। यह इवैल्यूएशन की बिल्कुल समान संख्या करने के लिए 18–30x की धीमी गति है। स्मार्ट सैंपलर कुछ अतिरिक्त इवैल्यूएट नहीं कर रहे हैं; वे वह समय अपनी ही ask/tell मशीनरी के भीतर खर्च कर रहे हैं।

दूसरा — और यही वह हिस्सा है जो कहानी को ईमानदार बनाए रखता है — किसी भी विधि को पॉज़िटिव आउट-ऑफ-सैंपल नतीजा नहीं मिला। हर TEST वैल्यू नेगेटिव है। सिंगल-टाइमफ्रेम रीजीम में हमारी स्ट्रैटेजी के पास वाकई कोई टिकाऊ OOS एज नहीं है, इसलिए "कौन सी विधि जीतती है" यह अंतिम मुनाफे के बारे में सवाल नहीं है; यह सर्च एफिशिएंसी के बारे में सवाल है। और तय इवैल बजट पर सर्च एफिशिएंसी में, डम्ब विधियां साफ तौर पर जीतती हैं: Sobol और random स्मार्ट सैंपलर जितने या उनसे बेहतर होल्ड-आउट आंकड़े हासिल करते हैं, जबकि वे वॉल-क्लॉक का केवल 1/20वां हिस्सा खर्च करते हैं।

अब तुलना को उस तरह पलट दें जैसे कोई प्रैक्टिशनर वाकई इसका अनुभव करता है — वॉल-क्लॉक को तय रखें, इवैल की गिनती को नहीं। अगर आप हर विधि को वे 15.8 सेकंड दें जो ASHA को अपने 1,500 evals के लिए चाहिए थे, तो Sobol 1,500 पर नहीं रुकता। यह चलता रहता है, लगभग 45,000 कॉन्फ़िगरेशंस तक। सस्ते रीजीम में सवाल कभी भी "कौन सा सैंपलर 1,500 पॉइंट्स को सबसे अच्छी तरह रखता है" नहीं होता — सवाल यह होता है "जब हर पॉइंट लगभग मुफ्त हो, तो क्या आप 1,500 चतुराई से रखे गए पॉइंट्स चाहेंगे या 45,000 scrambled पॉइंट्स?" लगभग-मुफ्त इवैल के साथ, ब्रेड्थ जीतती है। 7-आयामी स्पेस की तीस गुना ज़्यादा कवरेज उसके बेहतर मॉडल को मात देती है।

ask/tell टैक्स

यह 20x कहां जाता है? बैकटेस्ट में नहीं — वह सभी विधियों में समान है। यह सैंपलर की प्रति-पॉइंट बहीखाता (bookkeeping) में जाता है, जो Python में, लूप के भीतर चलती है:

• TPE हर ask पर kernel-density estimates की एक जोड़ी (अच्छे बनाम बुरे ट्रायल) फिट करता है, और कॉस्ट ट्रायल हिस्ट्री के साथ बढ़ती जाती है। Multivariate TPE इन्हें आयामों में मिलाकर संयुक्त रूप से फिट करता है — ज़्यादा मॉडलिंग, ज़्यादा Python।
• CMA-ES हर generation में एक covariance matrix को अपडेट करता है और उससे सैंपल लेता है। यहां TPE से सस्ता (यह ~850 cfg/s पर चला), लेकिन फिर भी एक Sobol पॉइंट जारी करने से एक ऑर्डर ऑफ मैग्निट्यूड ज़्यादा ओवरहेड।
• ASHA pruner की promotion/rung बहीखाता और, हमारे folds-as-fidelity डिज़ाइन में, कुछ भी prune करने से पहले फिक्स्ड इंडिकेटर precompute की कीमत चुकाता है — इसलिए इसके "बचाए गए" इवैल्यूएशन उतनी बचत नहीं करते जितनी अकाउंटिंग बताती है।

इसमें से कुछ भी एल्गोरिदम्स पर तंज नहीं है। मुद्दा यह है: ask/tell कॉस्ट प्रति पॉइंट लगभग एक तय संख्या के मिलीसेकंड होती है, और जब यह जिस इवैल को रैप करती है वह भी कुछ मिलीसेकंड का हो, तो वह फिक्स्ड कॉस्ट अचानक आपके बजट का 90% बन जाती है। स्मार्ट सैंपलर अपने वॉल-क्लॉक का नौ-दसवां हिस्सा यह सोचने में खर्च करता है कि कहां देखा जाए और एक-दसवां हिस्सा असल में देखने में। एक scrambled Sobol सीक्वेंस उसका सारा हिस्सा देखने में खर्च करती है। जब देखना सस्ता हो, तो देखना जीतता है।

हमने जानबूझकर यहां एक पूर्ण Gaussian-process बायेसियन ऑप्टिमाइज़र को बेंचमार्क नहीं किया, और उसी कारण से: एक GP surrogate ट्रायल गिनती में $O(n^3)$ है। एक ऐसे इवैल के सामने जिसकी कीमत मिलीसेकंड में हो, surrogate को फिट करने में ही पूरा सर्च बजट खप जाएगा, इससे पहले कि वह स्पेस के किसी सार्थक हिस्से को इवैल्यूएट कर पाए। सस्ते रीजीम में, GP-BO अंकगणित द्वारा ही अयोग्य ठहरा दिया जाता है।

महंगा रीजीम: क्रॉसओवर पलट जाता है

अब हम एक बैकटेस्ट को महंगा बनाते हैं। मल्टी-टाइमफ्रेम स्ट्रैटेजी एक हाई, एक मिड, और एक लो टाइमफ्रेम (triple-TF) को स्टैक करती है, हर एक अपना इंडिकेटर पास और अपनी खुद की थ्रेशोल्ड्स लाता है, सभी को उसी मल्टी-फोल्ड walk-forward पर स्कोर किया जाता है। एक सिंगल इवैल्यूएशन अब 0.3 मिलीसेकंड की बजाय लगभग 0.1–0.5 सेकंड की कीमत रखता है — तीन ऑर्डर ऑफ मैग्निट्यूड की छलांग। इवैल कॉस्ट हमारे भाजक के राउंडिंग-एरर टर्म से हटकर प्रभावी टर्म बन गई है। थीसिस के अनुसार, ask/tell टैक्स का मायने खत्म हो जाना चाहिए और स्मार्टनेस का भुगतान शुरू हो जाना चाहिए। ऐसा ही होता है।

हमने triple-TF समस्या (एक 18-पैरामीटर स्पेस) पर हर विधि को एक तय ~150-सेकंड वॉल-क्लॉक बजट के तहत चलाया, हर एक को वह बजट अपने सैंपलर के निर्देशानुसार खर्च करने दिया, और उसके द्वारा लौटाए गए सबसे अच्छे सिंगल कॉन्फ़िग को एक होल्ड-आउट टेस्ट विंडो पर इवैल्यूएट किया:

TEST वही walk-forward ऑब्जेक्टिव है जो पहले था। केवल एक विधि ने शून्य पार किया।

डम्ब Sobol बेसलाइन, जो सस्ते रीजीम में हावी था, अब −673 के साथ सबसे आखिरी स्थान पर है। एक 18-आयामी स्पेस की blind low-discrepancy sampling, जिसके पास खर्च करने के लिए केवल 349 इवैल्यूएशन हैं क्योंकि हर एक महंगा है, कभी भी किसी चीज़ को लोकलाइज़ नहीं करती। स्मार्ट विधि, sobol→cmaes — एक basin को seed करने के लिए बजट का 30% Sobol पर, फिर सबसे अच्छे seed से CMA-ES रिफाइनमेंट — वह इकलौती विधि है जिसने कोई पॉज़िटिव आउट-ऑफ-सैंपल नतीजा दिया। अंतिम अछूते होल्डआउट पर चैंपियन ने +2.62% लौटाया (19 ट्रेड्स, ~6.6% कैपिटल एक्सपोज़र) एक ऐसी टेस्ट विंडो के ऊपर जिसने +16.35% लौटाया (46 ट्रेड्स, ~15.7% एक्सपोज़र)। हर प्रतिस्पर्धी के चैंपियन ने आउट-ऑफ-सैंपल में पैसा गंवाया।

यही क्रॉसओवर है, जो एक ही स्ट्रैटेजी फैमिली, एक ही ऑब्जेक्टिव, एक ही मशीन पर मापा गया: एक इवैल्यूएशन की कीमत के अलावा कुछ भी न बदलें, और सर्च विधियों की रैंकिंग उलट जाती है। सस्ते रीजीम में Sobol जीतता है और स्मार्ट सैंपलर 20x की बर्बादी हैं; महंगे रीजीम में स्मार्ट सैंपलर ही इकलौती चीज़ है जो काम करती है और Sobol बर्बादी है।

यहां "स्मार्ट" क्यों जीतता है — और यह सिर्फ सैंपल-एफिशिएंसी नहीं है

इस कहानी का सुथरा संस्करण यह है कि "महंगे evals सैंपल-एफिशिएंसी को इनाम देते हैं, इसलिए वह विधि जीतती है जो कम, बेहतर पॉइंट्स रखती है।" यह आधा सच है, और डेटा ईमानदार, ज़्यादा दिलचस्प दूसरे आधे हिस्से को सामने लाने पर मजबूर करता है।

एक बार फिर eval की गिनतियां देखें। sobol→cmaes blind Sobol से कम पॉइंट्स इवैल्यूएट करके नहीं जीता — इसने Sobol के 349 के मुकाबले 15,239 इवैल्यूएट किए, उसी 150 सेकंड में चालीस गुना ज़्यादा। कैसे? क्योंकि हमारी multi-TF eval कॉस्ट संरचित (structured) है, समान नहीं। यहां दो एक्सिस हैं: एक महंगी इंडिकेटर एक्सिस (टाइमफ्रेम पीरियड्स और HMA लंबाइयां, हर एक की गणना में 30–500 ms, क्योंकि वे एक इंडिकेटर रीकंप्यूट को मजबूर करती हैं) और एक सस्ती थ्रेशोल्ड एक्सिस (एंट्री/एग्ज़िट सेपरेशन लेवल्स, cached signals पर हर एक ~1–2 ms)। इनके बीच का अंतर 30–100x है।

Blind Sobol इस संरचना को नज़रअंदाज़ करता है। इसका खींचा हर पॉइंट महंगी इंडिकेटर एक्सिस को हिलाता है, एक ताज़ा रीकंप्यूट को मजबूर करते हुए — इसलिए यह सभी 349 इवैल्यूएशन पर पूरी कीमत चुकाता है। sobol→cmaes, एक बार जब CMA-ES ने किसी संभावित क्षेत्र को लोकलाइज़ कर लिया हो, तो coarse इंडिकेटर संरचना को मोटे तौर पर तय रखने और continuous थ्रेशोल्ड्स को perturb करने की प्रवृत्ति रखता है, जो cached signals पर उतरते हैं और लगभग कुछ भी खर्च नहीं करते। स्मार्ट विधि उसी वॉल-क्लॉक को दोनों बेहतर-रखे गए पॉइंट्स और उनकी कहीं ज़्यादा संख्या में बदल देती है, क्योंकि यहां एडैप्टिव होने का मतलब है cost-aware होना: महंगी एक्सिस के टिक जाने के बाद सस्ती एक्सिस पर बने रहना। हमारा स्पष्ट cascade(sobol²×64) शोषण यह सबसे आक्रामक तरीके से करता है — cached signals पर सस्ती थ्रेशोल्ड्स को batch करके 20,864 evals — और जबकि यह triple-TF टेस्ट हार गया, दो-टाइमफ्रेम वेरिएंट में इसने टेस्ट विंडो को सीधे +20.2% पर जीत लिया (इससे पहले कि यह अपने खुद के होल्डआउट पर फेल हो जाए — इस बारे में आगे और)।

तो क्रॉसओवर का ज़्यादा तीखा बयान यह है: महंगे रीजीम में, ask/tell टैक्स नगण्य हो जाता है, जो आपको स्मार्ट होने के लिए आज़ाद कर देता है — और "स्मार्ट" का मतलब है ऑब्जेक्टिव की कॉस्ट संरचना के अनुसार ढलना, न कि सिर्फ उसके आकार के अनुसार। Blind sampling इनमें से कोई भी नहीं कर सकती। यही ठीक वह two-axis संरचना है जिसका शोषण करने के लिए हमारा adaptive-resolution drill-down इंजन बनाया गया है, और यही कारण है कि multi-fidelity विधियां महंगे रीजीम की हैं — बशर्ते एक शर्त पूरी हो।

फिडेलिटी: प्रूनिंग के लिए छिपी पूर्वशर्त

Multi-fidelity विधियां — Hyperband, ASHA, कोई भी early-stopping pruner — एक धारणा पर टिकी हैं: कि एक सस्ता, आंशिक इवैल्यूएशन कॉन्फ़िगरेशंस को उसी तरह रैंक करता है जैसे महंगा, पूर्ण इवैल्यूएशन करता। अगर एक कॉन्फ़िग जो एक walk-forward fold पर अच्छा दिखता है, वह उन सभी पर अच्छा दिखने की प्रवृत्ति रखता है, तो आप हारने वालों को जल्दी खत्म कर सकते हैं और बचे हुए (survivors) का बजट विजेताओं पर खर्च कर सकते हैं। अगर सस्ती फिडेलिटी रैंडम तरीके से रैंक करती है, तो early stopping सिर्फ अच्छे कॉन्फ़िग्स को coin-flip से फेंकना है।

इसलिए किसी भी pruner पर भरोसा करने से पहले, हम इस धारणा को सीधे मापते हैं। हमारी फिडेलिटी है walk-forward folds की संख्या (सस्ते में r folds पर इवैल्यूएट करें, या पूरी कीमत पर सभी K folds पर), और फिडेलिटी गेट सस्ते r-fold ऑब्जेक्टिव और पूर्ण ऑब्जेक्टिव के बीच Spearman rank correlation ρ की गणना random कॉन्फ़िग्स के एक सैंपल पर करता है। ρ@1 वह correlation है जब आप एक ही fold पर निर्णय करते हैं — सबसे आक्रामक, सबसे सस्ती फिडेलिटी। यहां बताया गया है कि उस गेट ने दोनों रीजीम में क्या रिपोर्ट किया:

सिंगल-टाइमफ्रेम रीजीम में, एक fold कॉन्फ़िग्स को सत्य के साथ ~0.03 के correlation से रैंक करता है — सांख्यिकीय रूप से रैंडम से अप्रभेद्य। यह संयोग नहीं है; यह वही तथ्य है जो "किसी भी विधि को OOS एज नहीं मिला" वाला है। जब किसी स्ट्रैटेजी के पास कोई टिकाऊ सिग्नल नहीं होता, तो उसका प्रति-fold प्रदर्शन ज़्यादातर किस्मत होता है, इसलिए कोई भी सिंगल fold लगभग-रैंडम ड्रॉ है और low-fidelity प्रूनिंग अच्छे कॉन्फ़िग्स को खत्म कर देगी और किस्मत वालों को प्रमोट कर देगी। यहां सस्ते रीजीम में multi-fidelity असुरक्षित है — इसलिए नहीं कि विधि खराब है, बल्कि इसलिए कि सस्ता सिग्नल नॉइज़ है। (हमारा गेट इसे फ्लैग करता है और आक्रामक तरीके से prune करने से इनकार करता है।)

मल्टी-टाइमफ्रेम रीजीम में, एक असली एज मौजूद है, और फिडेलिटी की तस्वीर बदल जाती है: ρ@1 बढ़कर 0.43 हो जाता है, और पांच folds तक ρ 0.91 तक चढ़ जाता है। अब एक fold असली रैंकिंग जानकारी लाता है और पांच folds लगभग इसका सब कुछ लाते हैं। Early stopping सुरक्षित बन जाता है — पहले जोड़े folds पर हारने वाला कॉन्फ़िग वाकई हारने वाला होने की संभावना रखता है। यह दूसरा कारण है कि multi-fidelity विधियां महंगे रीजीम की हैं: सिर्फ इसलिए नहीं कि महंगे evals प्रूनिंग को लायक बनाते हैं, बल्कि इसलिए कि महंगा रीजीम वह जगह है जहां सस्ती फिडेलिटी आखिरकार महंगी वाली की तरह रैंक करती है।

जो नियम यह आपके हाथ में देता है वह सीधा और चलाने में सस्ता है: prune करने से पहले ρ मापें। फिडेलिटी correlation कुछ सौ random कॉन्फ़िग्स पर एक दो-लाइन का कंप्यूटेशन है, और यही अंतर है multi-fidelity सर्च के आपको तेज़ करने और multi-fidelity सर्च के चुपचाप आपको तोड़फोड़ करने के बीच।

सर्च जीतना उसमें टिके रहना नहीं है

एक और ईमानदारी वाली बात, क्योंकि यह सीरीज़ उन बैकटेस्ट के बारे में है जो झूठ बोलते हैं। हमारा triple-TF चैंपियन, sobol→cmaes, पॉज़िटिव होल्डआउट दर्ज करने वाली इकलौती विधि थी — +2.62%, टेस्ट विंडो में +16.35% के ऊपर। यह अच्छी खबर है। यहां चेतावनी है: यह सांख्यिकीय deflation से नहीं बच पाया।

चैंपियन सभी विधियों में आज़माए गए दसियों हज़ार कॉन्फ़िगरेशंस में से सबसे अच्छा है। इतनी multiple testing के तहत, +2.62% का होल्डआउट अपने आप असली नहीं होता। हमने वे overfitting गेट्स चलाए जिन पर पूरी सीरीज़ टिकी है — Deflated Sharpe Ratio जिसे trials के बीच correlation के लिए effective-N से सही किया गया, और combinatorially-symmetric cross-validation के ज़रिए PBO। चैंपियन ने PBO पास किया (0.12, 0.2 की सीमा से आराम से नीचे — इसकी रैंक CSCV splits में स्थिर है) लेकिन इसका deflated Sharpe गिरकर शून्य हो गया (गेट ≥ 0.95 मांगता है)। नतीजा: नहीं टिकता।

इसे ध्यान से पढ़ें, क्योंकि यही पूरी कवायद का मुद्दा है। क्रॉसओवर नतीजा असली है: स्मार्ट सर्च ने महंगे रीजीम में सर्च जीती, निर्णायक रूप से, और Sobol हार गया। लेकिन सर्च जीतना ऑप्टिमाइज़र के बारे में एक बयान है, स्ट्रैटेजी के बारे में नहीं। एक अच्छा ऑप्टिमाइज़र edgeless स्पेस में से जो सबसे अच्छा कॉन्फ़िग खोज सकता है, वह अब भी edgeless है — deflation ही आपको बताता है कि आपके हाथ में कौन सा है। सही सर्च विधि चुनना आपको कुशलता से सबसे अच्छा उपलब्ध जवाब देता है; यह कोई ऐसा एज नहीं गढ़ता जो कभी था ही नहीं। ऑप्टिमाइज़र और overfitting गेट्स अलग-अलग चीज़ों को मापने वाले अलग-अलग यंत्र हैं, और आपको दोनों की ज़रूरत है।

एक निर्णय नियम जिसे आप वाकई लागू कर सकते हैं

एक ऑप्टिमाइज़र चुनने के लिए आपको हमारा बेंचमार्क दोबारा चलाने की ज़रूरत नहीं है। आपको बस एक नंबर चाहिए: एक बैकटेस्ट में कितना समय लगता है? अपने ऑब्जेक्टिव के एक सिंगल इवैल्यूएशन का समय नापें — एक पूर्ण walk-forward पास, सभी folds — और रीजीम पढ़ लें।

• सस्ता eval (≲ ~10 ms/backtest): थ्रूपुट खरीदें। scrambled Sobol/QMC या random का उपयोग करें। TPE/CMA-ES/ASHA पर ask/tell टैक्स आपको उस प्लेसमेंट के लिए 10–30x पॉइंट काउंट की कीमत चुकाएगा जिसका लगभग-मुफ्त eval कोई इनाम नहीं देता। multi-fidelity प्रूनिंग की परवाह मत करें — और अगर आपका मन ललचाए, तो पहले ρ@1 जांचें; एक कम-एज सस्ते रीजीम में यह संभवतः शून्य के करीब होगा, जिसका मतलब है कि प्रूनिंग coin-flipping है। बची हुई इंजीनियरिंग समय सर्च को चौड़ा करने में खर्च करें, उसे संकरा करने में नहीं।
• महंगा eval (≳ ~100 ms–सेकंड/backtest): सैंपल-एफिशिएंसी खरीदें। CMA-ES, TPE, या एक Sobol-seeded CMA-ES हाइब्रिड का उपयोग करें; सैंपलर ओवरहेड अब eval के मुकाबले एक राउंडिंग एरर है। अगर आपकी eval कॉस्ट संरचित है (एक धीमी इंडिकेटर एक्सिस और एक तेज़ थ्रेशोल्ड एक्सिस, जैसे multi-TF में), तो उन विधियों को प्राथमिकता दें जो उस संरचना का शोषण करती हैं — cascades, drill-downs, कुछ भी cost-aware — उन विधियों के मुकाबले जो हर आयाम को समान रूप से महंगा मानती हैं।
• बीच में, या अनिश्चित होने पर: एक Sobol-seeded हाइब्रिड (sobol→cmaes) मज़बूत डिफ़ॉल्ट है। यह शुरुआत में breadth-first Sobol की तरह व्यवहार करता है (सस्ता, फिट करने के लिए कोई मॉडल नहीं) और बाद में एक स्मार्ट रिफाइनर की तरह, इसलिए यह चाहे जिस भी रीजीम में हो, धीरे-धीरे और सुंदर तरीके से घटता है — यही ठीक कारण है कि यह हमारा महंगा-रीजीम चैंपियन था।
• किसी भी pruner से पहले, फिडेलिटी मापें। कुछ सौ random कॉन्फ़िग्स पर सस्ती फिडेलिटी और पूर्ण ऑब्जेक्टिव के बीच Spearman ρ की गणना करें। अगर ρ@1 कम है, तो एक fold पर prune न करें; न्यूनतम संसाधन को तब तक बढ़ाएं जब तक ρ ~0.5 पार न कर ले। इसकी कीमत कोड की दो लाइनें हैं और यह आपके एक्सेलेरेटर को आपके सबसे अच्छे कॉन्फ़िग्स को चुपचाप फेंकने से रोकता है।
• सर्च में जो भी जीते, deflation गेट्स चलाएं। ऑप्टिमाइज़र का विजेता वह ऑब्जेक्ट है जो पूरे हफ्ते में सबसे ज़्यादा overfit-prone होगा। यह DSR और PBO हैं, न कि ऑप्टिमाइज़र का स्कोर, जो तय करते हैं कि यह ट्रेड करने लायक है या नहीं।

यह कहां जुड़ता है

यह नतीजा उन कुछ धागों के केंद्र में बैठता है जिन्हें यह सीरीज़ खींच रही है:

• यह मानकर चलता है कि नीचे का इंजन ईमानदार है। पूरा सस्ता-रीजीम फायदा इसलिए मौजूद है क्योंकि हमारा in-process numba इंजन बिना किसी IPC के प्रति सेकंड हज़ारों कॉन्फ़िग्स तक पहुंचता है — स्पीड लैडर ही वह चीज़ है जो सबसे पहले आपको थ्रूपुट-जीतता-है रीजीम में डालती है। एक धीमा, फ्रेमवर्क-टैक्स्ड इंजन हर समस्या को डिफ़ॉल्ट रूप से महंगे रीजीम में डाल देगा, और आप कभी भी क्रॉसओवर नहीं देख पाएंगे।
• महंगा-रीजीम शोषण वही two-axis कॉस्ट संरचना है जिसके इर्द-गिर्द हमारा adaptive-resolution drill-down इंजन डिज़ाइन किया गया है: coarse, महंगी एक्सिस पर लोकलाइज़ करें, फिर fine, सस्ती एक्सिस का शोषण करें।
• यहां हर विधि केवल इसलिए भरोसेमंद है क्योंकि इंजन लीक-फ्री है। दसियों हज़ार trials पर एक सर्च एक look-ahead बग को ढूंढने और उसका शोषण करने के लिए सबसे कुशल संभव मशीन है — "विजेता" वही कॉन्फ़िग होता जो लीक पर सबसे ज़्यादा टिका होता। पहले घड़ी ठीक करें, फिर सर्च करें।
• और चैंपियन की किस्मत — सर्च जीतना, deflation में फेल होना — यही पूरी दलील है पैरामीटर सर्च और ओवरफिटिंग कंट्रोल को अलग-अलग यंत्रों के साथ अलग-अलग चरणों के रूप में मानने की।

अकादमिक पृष्ठभूमि वही है जिस पर यह क्षेत्र बार-बार लौटता है: Bergstra और Bengio (2012) इस पर कि रैंडम ग्रिड को क्यों मात देता है; Li et al. का Hyperband (2018) और ASHA follow-up (2020) multi-fidelity पर; और Bailey और López de Prado (2014) इस पर कि किसी भी बड़ी सर्च के विजेता को भरोसा किए जाने से पहले deflate क्यों किया जाना चाहिए। इनमें से कोई भी एक इकलौता सबसे अच्छा ऑप्टिमाइज़र नहीं बताता, क्योंकि ऐसा कोई है ही नहीं — एक रीजीम है, और एक कॉस्ट है जो उसे चुनती है।

मुख्य बातें

1. रैंडम और स्मार्ट सर्च के बीच का क्रॉसओवर इवैल्यूएशन कॉस्ट से तय होता है, एल्गोरिदम से नहीं। हमने केवल यह बदलकर कि एक बैकटेस्ट कितना महंगा था, हर विधि की रैंकिंग उलट दी।
2. सस्ता eval → डम्ब Sobol थ्रूपुट पर जीतता है। हमारे single-TF इंजन (~3–4k cfg/s) पर, TPE और ASHA समान eval गिनती के लिए 18–30x धीमे चले — Sobol के ~2,830 के मुकाबले ~95–154 cfg/s। बराबर वॉल-क्लॉक पर, जब हर पॉइंट लगभग मुफ्त हो, तो ब्रेड्थ स्पेस के बेहतर मॉडल को मात देती है।
3. महंगा eval → स्मार्ट विधियां एफिशिएंसी पर जीतती हैं। triple-TF समस्या पर, sobol→cmaes इकलौती विधि थी जिसने पॉज़िटिव आउट-ऑफ-सैंपल नतीजा खोजा (+16.35% टेस्ट, +2.62% होल्डआउट); blind Sobol सबसे आखिरी स्थान पर रहा।
4. महंगे रीजीम में, "स्मार्ट" का मतलब है cost-aware। विजेता ने महंगी इंडिकेटर एक्सिस और सस्ती थ्रेशोल्ड एक्सिस के बीच 30–100x के अंतर का शोषण किया — इसने ज़्यादा evals किए और उन्हें बेहतर तरीके से रखा, महंगी एक्सिस के तय हो जाने के बाद सस्ती एक्सिस पर बने रहकर।
5. फिडेलिटी प्रूनिंग के लिए पूर्वशर्त है। सिंगल-fold rank correlation ρ@1 ≈ 0.03 (single-TF, अनिवार्यतः रैंडम) से बढ़कर 0.43 (multi-TF) हो गया, पांच folds तक 0.91 तक पहुंचा। Multi-fidelity/ASHA तभी फायदा देता है जब सस्ती फिडेलिटी महंगी वाली की तरह रैंक करे — इसलिए prune करने से पहले ρ मापें।
6. सर्च जीतना उसमें टिके रहना नहीं है। चैंपियन ने PBO पास किया लेकिन Deflated Sharpe गेट में फेल हो गया। ऑप्टिमाइज़र को eval कॉस्ट से चुनें; ट्रेड करने योग्यता का फैसला deflation गेट्स से करें। ये अलग-अलग यंत्र हैं, और आपको दोनों की ज़रूरत है।

अपना ऑप्टिमाइज़र इस आधार पर चुनें कि एक बैकटेस्ट की कीमत क्या है। फिर याद रखें कि एक edgeless स्पेस में ऑप्टिमाइज़र जो सबसे अच्छा जवाब खोज सकता है, वह अब भी edgeless है — और यह गेट्स को तय करने दें, सर्च को नहीं, कि आपके हाथ में कौन सा है।