AI एजेंट्स का ऐसा झुंड कैसे बनाएं जो 24/7 अल्फा (Alpha) की तलाश करे

मैं समझाऊंगा कि कैसे AI एजेंटों का एक झुंड (स्वॉर्म) बनाया जाए जो पूरी क्वांट रिसर्च टीम की जगह ले सकता है।

चलिए सीधे मुद्दे पर आते हैं।

इसे बुकमार्क करें

- मैं रोन हूं, एक बैकएंड डेवलपर जो सिस्टम डिज़ाइन, HFT-शैली निष्पादन, और क्वांटिटेटिव ट्रेडिंग सिस्टम पर काम करता हूं। मेरा काम इस बात पर केंद्रित है कि प्रेडिक्शन मार्केट लोड के तहत वास्तव में कैसे व्यवहार करते हैं। किसी भी सुझाव, विचारशील सहयोग, या साझेदारी के लिए DM खुले हैं।

अपने पिछले लेख में मैंने कहा था कि मैं AI क्वांट सिस्टम बनाने वाले पहले 20 लोगों के सेटअप को व्यक्तिगत रूप से देखूंगा। मैं अपनी बात का पक्का हूं।

चार बिल्डर पहले से ही मेरे साथ इस प्रक्रिया में गहराई से जुड़े हुए हैं। उनमें से एक अभी इसी समय पूर्ण स्व-सुधार हेज फंड लूप चला रहा है।

यह ऑफर अभी भी खुला है।

यदि आप एक अल्फा रिसर्च सिस्टम बना रहे हैं, शुरू करने वाले हैं, या बस इसके बारे में सोच रहे हैं, तो इस लेख के नीचे जवाब दें या मुझे अपना मौजूदा सेटअप DM करें। मैं व्यक्तिगत रूप से आपके आर्किटेक्चर की समीक्षा करूंगा और आपको दिखाऊंगा कि आपके पास जो है और एक ऐसे झुंड के बीच क्या अंतर है जो अपने आप अल्फा का शिकार करता है।

अगर मैं जवाब नहीं देता, तो आप पहले 20 में नहीं थे। तेज़ी से आगे बढ़ें।

अधिकांश क्वांट आज भी उसी तरह अल्फा का शिकार करते हैं जैसे वे एक दशक पहले करते थे।

वे एक पेपर पढ़ते हैं। वे एक Jupyter नोटबुक खोलते हैं। वे कुछ फीचर इंजीनियर करते हैं। वे एक बैकटेस्ट चलाते हैं। वे Sharpe अनुपात पर नज़र डालते हैं। वे अगले विचार पर चले जाते हैं।

वे ही पाइपलाइन हैं।

शोध का हर चरण वे स्वयं हैं, एक स्क्रीन के सामने बैठे, एक समय में एक परिकल्पना चला रहे हैं।

दुनिया के सबसे चतुर क्वांट बिल्डरों ने ऐसा करना बंद कर दिया है।

वे झुंड बनाते हैं। झुंड में प्रत्येक एजेंट शोध के एक चरण का मालिक होता है। एजेंट समानांतर में काम करते हैं। झुंड लगातार चलता रहता है। जब वे सोते हैं तब हर सुबह नया अल्फा दिखाई देता है।

बोरिस चेर्नी, Anthropic में Claude Code के प्रमुख, ने दो सप्ताह पहले यह कहा था। "मैं अब Claude को प्रॉम्प्ट नहीं करता। मेरे पास लूप चल रहे हैं जो Claude को प्रॉम्प्ट करते हैं और पता लगाते हैं कि क्या करना है। मेरा काम लूप लिखना है।"

उस एक वाक्य ने दुनिया भर के हर गंभीर बिल्डर के AI के बारे में सोचने के तरीके को फिर से परिभाषित कर दिया।

क्वांट शोध के लिए यह सब कुछ बदल देता है।

क्योंकि अल्फा शोध पहले से ही एक पाइपलाइन है। पेपर पढ़ें। परिकल्पना निकालें। फीचर इंजीनियर करें। 20 साल के डेटा पर बैकटेस्ट करें। महत्व की जाँच करें। जाँच करें कि क्या सिग्नल विभिन्न शासनों (regimes) में जीवित रहता है। हर ज्ञात कारक के विरुद्ध विघटित करें।

वॉल स्ट्रीट का हर गंभीर फंड उसी सटीक पाइपलाइन को चलाता है। Renaissance इसे 100 PhD के साथ चलाता है। Two Sigma इसे 200 के साथ चलाता है। Citadel इसे और अधिक के साथ चलाता है।

एकमात्र अंतर यह है कि उन्हें पाइपलाइन के अंदर सैकड़ों मनुष्यों की आवश्यकता होती है। आपको नहीं है।

AI एजेंटों का एक झुंड आपके लिए उस पाइपलाइन के हर चरण को चला सकता है। प्रत्येक एजेंट विशिष्ट। प्रत्येक एजेंट उस मॉडल पर चल रहा है जो उसकी जटिलता के अनुकूल हो। ये सभी 24/7 समानांतर में चल रहे हैं।

मैं पिछले कुछ दिनों से यह झुंड बना रहा हूं।

यह रात भर में नए शोध पत्र पढ़ता है। यह उनके अंदर के गणित का अध्ययन करता है। यह दावा की जा रही सटीक परिकल्पना को निकालता है। यह आवश्यक फीचर इंजीनियर करता है। यह 20 साल के इतिहास के विरुद्ध सिग्नल का बैकटेस्ट करता है। यह सांख्यिकीय कठोरता लागू करता है। यह ओवरफिटिंग की जाँच करता है। यह किसी भी ऐसी चीज़ को फ़्लैग करता है जो केवल एक बाजार शासन में काम करती है।

इस लेख के अंत तक आप छह-एजेंट अल्फा रिसर्च झुंड के सटीक आर्किटेक्चर को जान जाएंगे।

आप उस टूल को जान जाएंगे जो आपको इसे एक सप्ताहांत में बनाने देता है, बिना अपना खुद का एजेंट फ्रेमवर्क लिखे।

और आप उन पांच विफलता मोड को जान जाएंगे जो 90 प्रतिशत खुदरा प्रयासों को मार देते हैं।

चलिए इसमें गोता लगाते हैं।

भाग 1: एक झुंड वास्तव में क्या है

एक प्रॉम्प्ट एक प्रश्न है। आप पूछते हैं, मॉडल एक बार उत्तर देता है, और वह रुक जाता है।

एक लूप एक कार्य है। एजेंट काम करता रहता है, अपनी प्रगति की जाँच करता है, और तब तक चलता रहता है जब तक कार्य वास्तव में पूरा न हो जाए।

एक झुंड समानांतर में चलने वाले कई लूप हैं। प्रत्येक लूप एक विशेषज्ञ है। प्रत्येक विशेषज्ञ पाइपलाइन के एक चरण का मालिक है। एक का आउटपुट अगले के इनपुट को फीड करता है।

यह पूरा मानसिक मॉडल है।

यदि आपने Claude Code, Cursor, या Codex का उपयोग किया है, तो आपने बिना जाने एक लूप का उपयोग किया है। एजेंट एक मॉडल को कॉल करता है, मॉडल एक कार्रवाई चुनता है, कार्रवाई चलती है, परिणाम वापस मॉडल के पास जाता है, और यह तब तक दोहराता है जब तक लक्ष्य पूरा नहीं हो जाता।

लूप ही एक एजेंट को एक एकल उत्तर के बजाय एक एजेंट बनाता है।

एक झुंड ही एक शोध टीम को एक शोधकर्ता के टाइप करने के बजाय एक टीम बनाता है।

भाग 2: वह उपकरण जो झुंड को चलाता है

आप इसे Python स्क्रिप्ट के साथ स्वयं बनाने का प्रयास कर सकते हैं जो विभिन्न API को कॉल करती हैं।

मैंने कोशिश की। यह उसी क्षण टूट जाता है जब एक एजेंट को दूसरे की प्रतीक्षा करनी होती है। यह उसी क्षण टूट जाता है जब आपको चक्रों में स्थिति बनाए रखने की आवश्यकता होती है। यह उसी क्षण टूट जाता है जब आप विभिन्न मॉडलों पर समानांतर में छह लूप चलाना चाहते हैं।

आप शोध करने के बजाय अपना खुद का एजेंट फ्रेमवर्क खरोंच से बनाने लगते हैं।

फिर मुझे Slate मिला।

Slate @wearerandomlabs द्वारा बनाया गया एक AI कोडिंग हार्नेस है। यह आपके टर्मिनल में चलता है। यह किसी भी कार्य को आपके कोडबेस में सबएजेंटों के झुंड में फैला देता है। यह किसी भी चरण पर आपकी पसंद का कोई भी मॉडल चुनता है। आपकी मौजूदा सदस्यता काम करती है।

इस झुंड के लिए मैं इसका उपयोग करने का कारण एक क्षमता है जिसे उन्होंने अभी लॉन्च किया है जिसे Programs कहा जाता है।

एक Program JavaScript में लिखा गया एक लूप है जिसे Slate आपके लिए चलाता है।

एक प्रॉम्प्ट एक बार चलता है और रुक जाता है। एक Program एक इंजीनियर्ड लूप है। यह लगातार चलता है। यह रनों के बीच स्थिति बनाए रखता है। यह तब तक चलता रहता है जब तक कार्य पूरा नहीं हो जाता।

आप तय करते हैं कि प्रत्येक चरण पर क्या होता है। कौन सा मॉडल किस चरण को संभालता है। जारी रखने से पहले लूप क्या जाँच करता है। यह कब रुकता है।

आप Program अकेले नहीं लिखते। आप Slate को बताते हैं कि आप क्या चाहते हैं और यह आपके साथ कदम दर कदम लूप का मसौदा तैयार करता है। यह लूप को सहेजता है। यह इसे चलाता है। यह इसे चलाता रहता है।

क्योंकि लूप कोड है, यह स्थिति धारण कर सकता है, आपके कोडबेस के साथ बातचीत कर सकता है, बाहरी API को हिट कर सकता है, Slack पर पोस्ट कर सकता है, और आपके द्वारा चुने गए मॉडलों के किसी भी संयोजन पर समानांतर में कई सबएजेंटों को ऑर्केस्ट्रेट कर सकता है। आसान काम के लिए सस्ता ओपन-वेट मॉडल। कठिन तर्क के लिए फ्रंटियर मॉडल। जो भी चरण में फिट बैठता है।

छह-एजेंट शोध झुंड के लिए, यह बिल्कुल वही परत है जो पहले गायब थी।

आप Slate को https://randomlabs.ai पर पा सकते हैं। यह आज उपलब्ध है।

अब मैं आपको झुंड दिखाता हूं।

भाग 3: छह एजेंट

हर गंभीर क्वांट फंड शोध के समान छह चरण चलाता है।

यहाँ वह झुंड है जो उनकी जगह लेता है।

एजेंट 1: विचार जनरेटर।

हर रात arXiv q-fin, SSRN, और वित्तीय पत्रिकाओं से नए शोध पत्र पढ़ता है।

प्रत्येक पेपर द्वारा प्रस्तावित गणितीय मॉडल का अध्ययन करता है। दावा की जा रही सटीक परिकल्पना, आवश्यक डेटा और अनुमानित सिग्नल की दिशा निकालता है।

प्रत्येक परिकल्पना को एक संरचित शोध टिकट के रूप में लिखता है जिसे अगला एजेंट उठा सकता है।

तेज़ लागत-कुशल मॉडल पर चलता है क्योंकि कार्य उच्च-मात्रा संरचित निष्कर्षण है।

एजेंट 2: फीचर इंजीनियर।

एक परिकल्पना टिकट लेता है। मूल्य डेटाबेस या मौलिक डेटाबेस से आवश्यक डेटा खींचता है।

फीचर वेक्टर का निर्माण करता है। क्रॉस-सेक्शन में मानकीकृत करता है। लापता प्रेक्षणों, तीन मानक विचलनों से परे आउटलायर्स और लुक-अहेड बायस को संभालता है।

बैकटेस्टिंग के लिए तैयार एक साफ डेटाफ्रेम आउटपुट करता है।

एजेंट 3: बैकटेस्टर।

फीचर वेक्टर लेता है। पोर्टफोलियो निर्माण नियम बनाता है। यथार्थवादी लेन-देन लागत, शॉर्ट साइड पर उधार लेने की लागत और स्लिपेज के साथ 20 साल के डेटा पर ऐतिहासिक बैकटेस्ट चलाता है।

Sharpe अनुपात, अधिकतम ड्रॉडाउन, टर्नओवर और क्षमता अनुमान आउटपुट करता है।

एजेंट 4: वैलिडेटर।

यह वह जगह है जहाँ कठोरता रहती है।

बैकटेस्ट परिणाम लेता है। रिटर्न श्रृंखला में ऑटोसहसंबंध को ठीक करने के लिए Newey-West समायोजित t-सांख्यिकी चलाता है। यह जाँचने के लिए 10,000 पुनरावृत्तियों के साथ बूटस्ट्रैप रीसैंपलिंग चलाता है कि Sharpe वास्तविक है या एक नमूना कलाकृति।

किसी भी सिग्नल को फ़्लैग करता है जो महत्व सीमा में विफल रहता है। 30 प्रतिशत से अधिक इन-सैंपल बनाम आउट-ऑफ-सैंपल गिरावट वाली किसी भी चीज़ को मार देता है, क्योंकि यह ओवरफिटिंग है।

एक मजबूत तर्क मॉडल पर चलता है। निर्माता कभी भी अपने स्वयं के काम को मान्य नहीं करता है। कभी नहीं।

एजेंट 5: शासन लेखा परीक्षक।

वे सिग्नल लेता है जो सत्यापन पास कर चुके हैं। 20 साल के इतिहास को शासन द्वारा विभाजित करता है (अस्थिरता और रिटर्न पर एक छिपे हुए मार्कोव मॉडल के माध्यम से पहचाना गया)।

प्रत्येक शासन के अंदर Sharpe, ड्रॉडाउन और हिट दर की पुनर्गणना करता है। किसी भी ऐसी चीज़ को मार देता है जो केवल एक शासन में काम करती है, क्योंकि यह अल्फा के रूप में प्रच्छन्न शासन समय है।

एजेंट 6: कारक विघटनकर्ता।

शासन-मजबूत सिग्नल लेता है। उन्हें Fama-French पांच कारक मॉडल और Carhart मोमेंटम और एक कम-अस्थिरता कारक के विरुद्ध प्रतिगमन करता है।

अवशिष्ट अल्फा (प्रतिगमन का अवरोधन) और इसकी t-सांख्यिकी की रिपोर्ट करता है।

केवल वे सिग्नल जहां अवशिष्ट अल्फा कारक अपघटन से बचता है, वास्तविक नया अल्फा है। बाकी सब कुछ अतिरिक्त चरणों के साथ पुनर्पैकेज्ड मोमेंटम या पुनर्पैकेज्ड वैल्यू है।

छह एजेंट। प्रत्येक एक चरण का मालिक है। वे अपने आउटपुट को श्रृंखला में नीचे भेजते हैं।

एक Slate Program। छह विशिष्ट एजेंट। हर 24 घंटे में चलता है।

पूरा झुंड एक Slate Program पर चलता है जो हर 24 घंटे में फायर करता है।

भाग 4: इसे चरण दर चरण कैसे बनाएं

यहाँ सटीक निर्माण है। साथ चलें और दिन के अंत तक आपके पास झुंड चल रहा होगा।

चरण 1: Slate स्थापित करें

अपना टर्मिनल खोलें और चलाएँ:

1npm install -g @randomlabs/slate

Slate 30 सेकंड से भी कम समय में एक वैश्विक CLI के रूप में स्थापित हो जाता है।

फिर प्रोजेक्ट निर्देशिका बनाएँ:

1mkdir alpha-swarm
2cd alpha-swarm
3slate init

slate init प्रोजेक्ट को उन फ़ोल्डरों के साथ तैयार करता है जिनकी आपको स्थिति, Programs और प्रदाताओं के लिए आवश्यकता है।

चरण 2: अपने मॉडल कनेक्ट करें

चलाएँ:

1slate /providers

यह Slate CLI के अंदर प्रदाता कॉन्फ़िगरेशन स्क्रीन खोलता है। उन मॉडलों को कनेक्ट करें जिनका आप उपयोग करना चाहते हैं।

इस झुंड के लिए मैं तेज़ एजेंटों (विचार निर्माण, फीचर इंजीनियरिंग, बैकटेस्टिंग, शासन लेखा परीक्षा) पर Sonnet और तर्क-भारी एजेंटों (सत्यापन और कारक अपघटन) पर Opus का उपयोग करता हूं।

चरण 3: Program का मसौदा तैयार करें

Slate प्रारंभ करें:

1slate

फिर Slate CLI में टाइप करें:

मेरे लिए एक Program तैयार करें जो क्रम में छह शोध एजेंट चलाता है: विचार जनरेटर, फीचर इंजीनियर, बैकटेस्टर, वैलिडेटर, शासन लेखा परीक्षक, कारक विघटनकर्ता। इसे हर 24 घंटे में चलाएं। तेज़ एजेंटों के लिए sonnet और सत्यापन और कारक अपघटन के लिए opus का उपयोग करें।

Slate आपके साथ Program का मसौदा तैयार करता है। यह स्पष्ट करने वाले प्रश्न पूछता है। कौन सा डेटा स्रोत। कौन सी बैकटेस्ट विंडो। कौन सी Sharpe सीमा। कौन सा शासन वर्गीकारक। आप प्राकृतिक भाषा में उत्तर देते हैं। Slate JavaScript लिखता है।

यहाँ वह लूप है जो लिखे जाने के बाद दिखता है:

1export default async function alphaSwarm(slate) {
2  while (true) {
3    // चरण 1: पेपर पढ़ें, परिकल्पनाएँ निकालें
4    const hypotheses = await slate.agent('idea-generator', {
5      model: 'sonnet',
6      task: 'पिछले 24 घंटों से arXiv q-fin और SSRN पढ़ें। दावा की गई दिशा, आवश्यक डेटा और पेपर संदर्भ के साथ 10 अल्फा परिकल्पनाएँ निकालें।',
7      state: slate.state.get('tested-hypotheses')
8    });
9
10    // चरण 2: फीचर इंजीनियरिंग, प्रति परिकल्पना समानांतर में
11    const features = await Promise.all(
12      hypotheses.map(h => slate.agent('feature-engineer', {
13        model: 'sonnet',
14        task: `इसके लिए फीचर वेक्टर बनाएं: ${h.claim}. क्रॉस-सेक्शन मानकीकृत करें। लुक-अहेड संभालें।`,
15        data: slate.tools.priceData()
16      }))
17    );
18
19    // चरण 3: यथार्थवादी लागतों के साथ 20-वर्षीय बैकटेस्ट
20    const backtests = await Promise.all(
21      features.map(f => slate.agent('backtester', {
22        model: 'sonnet',
23        task: '20-वर्षीय बैकटेस्ट चलाएं। प्रति ट्रेड 5bps लेन-देन लागत और शॉर्टिंग लागत शामिल करें।',
24        features: f
25      }))
26    );
27
28    // चरण 4: तर्क मॉडल पर सांख्यिकीय सत्यापन
29    const validated = await Promise.all(
30      backtests.map(b => slate.agent('validator', {
31        model: 'opus',
32        task: 'Newey-West t-सांख्यिकी 2.5 से ऊपर। बूटस्ट्रैप 10k। अस्वीकार करें यदि IS/OOS Sharpe 30 प्रतिशत से अधिक घटता है।',
33        backtest: b
34      }))
35    );
36
37    // चरण 5: HMM के माध्यम से शासन विभाजन
38    const regimeChecked = await Promise.all(
39      validated
40        .filter(v => v.passed)
41        .map(v => slate.agent('regime-auditor', {
42          model: 'sonnet',
43          task: 'अस्थिरता और रिटर्न पर 3-अवस्था HMM फिट करें। प्रति शासन Sharpe की पुनर्गणना करें। अस्वीकार करें यदि केवल एक शासन काम करता है।',
44          result: v
45        }))
46    );
47
48    // चरण 6: अवशिष्ट अल्फा को अलग करने के लिए कारक अपघटन
49    const finalSignals = await Promise.all(
50      regimeChecked
51        .filter(r => r.passed)
52        .map(r => slate.agent('factor-decomposer', {
53          model: 'opus',
54          task: 'Fama-French 5 + Carhart मोमेंटम + कम-अस्थिरता के विरुद्ध प्रतिगमन करें। अवशिष्ट अल्फा और t-सांख्यिकी की रिपोर्ट करें।',
55          result: r
56        }))
57    );
58
59    // बनाए रखें, सूचित करें, सोएं
60    await slate.state.set('final-signals', finalSignals);
61    await slate.state.append('tested-hypotheses', hypotheses);
62    await slate.notify.slack('research', `${finalSignals.length} नए सिग्नल आज सभी छह चरणों में बच गए।`);
63    await slate.sleep('24h');
64  }
65}

यह पूरा झुंड है। एक फ़ाइल। छह एजेंट। हमेशा के लिए चलता है।

चरण 4: झुंड चलाएं

फ़ाइल सहेजें और चलाएँ:

1slate run alpha-swarm.js

जैसे ही आप एंटर दबाते हैं, Slate लूप को स्पिन कर देता है। छह एजेंट क्रम में फायर करते हैं।

फीचर इंजीनियरिंग प्रत्येक परिकल्पना पर समानांतर में चलती है। बैकटेस्ट समानांतर में चलते हैं। सत्यापन मजबूत मॉडल पर चलता है।

आप Slate CLI से वास्तविक समय में प्रत्येक एजेंट को काम करते हुए देख सकते हैं। प्रत्येक एजेंट अपनी स्थिति, अपना वर्तमान कार्य और अपनी प्रगति दिखाता है।

[स्क्रीनशॉट 4: टर्मिनल झुंड को समानांतर में कई एजेंटों के साथ चलता हुआ दिखा रहा है, प्रत्येक चरण के लिए प्रगति संकेतक दिखाई दे रहे हैं।]

पहला चक्र चरण एक द्वारा उत्पादित परिकल्पनाओं की संख्या के आधार पर 20 से 40 मिनट लेता है।

अंत में, Slate अपने Sharpe अनुपात, ड्रॉडाउन और अवशिष्ट अल्फा के साथ बचे हुए लोगों को आपके Slack चैनल पर पोस्ट करता है। फिर कल तक सो जाता है।

चरण 5: पुनरावृति करें

लूप का पहला संस्करण कभी भी अंतिम नहीं होता है।

विचार जनरेटर डुप्लिकेट उत्पन्न करेगा। Slate में टाइप करें:

राज्य इतिहास के विरुद्ध एक जाँच जोड़ें ताकि यह केवल उन परिकल्पनाओं का प्रस्ताव करे जिनका हमने पिछले 30 दिनों में परीक्षण नहीं किया है।

वैलिडेटर उन सिग्नलों को अस्वीकार कर देगा जिनके बारे में आपको लगता है कि उन्हें पास हो जाना चाहिए था। टाइप करें:

Sharpe सीमा को 1.2 तक ढीला करें लेकिन अधिकतम ड्रॉडाउन सीमा को 8 प्रतिशत तक कस दें।

Slate आपके लिए Program अपडेट करता है। अगला चक्र नए तर्क का उपयोग करता है। प्रत्येक सुधार राज्य फ़ाइल में समाहित हो जाता है, और समय के साथ झुंड तेज होता जाता है क्योंकि उसे वह सब कुछ याद रहता है जिसका उसने पहले ही परीक्षण किया है और वह सब कुछ जिसे उसने पहले ही अस्वीकार कर दिया है।

भाग 5: यह वास्तव में एक शोध टीम की जगह कैसे लेता है

तीन पैटर्न हर वास्तविक तैनाती को कवर करते हैं।

पैटर्न 1: रात भर की खोज।

झुंड रात 8 बजे से सुबह 8 बजे तक चलता है। हर सुबह आप दो या तीन सिग्नलों के साथ उठते हैं जो सभी छह चरणों में बच गए हैं।

आपका काम पाइपलाइन को स्वयं चलाने के बजाय बचे हुए लोगों की समीक्षा करना हो जाता है।

पैटर्न 2: परिकल्पना विस्फोट मोड।

नया पेपर आता है। नया डेटा स्रोत उपलब्ध होता है। आप मांग पर झुंड को फायर करते हैं और उसी दोपहर 100 परिकल्पनाओं का परीक्षण करवाते हैं।

एक मानव शोधकर्ता उसी समय में दो का परीक्षण करता है।

पैटर्न 3: अल्फा क्षय निगरानी।

झुंड हर सप्ताह ताजा डेटा के विरुद्ध मान्य सिग्नलों को फिर से चलाता है। जिस क्षण किसी सिग्नल का Sharpe सीमा से नीचे गिरता है, यह क्षय को फ़्लैग करता है।

आप ड्रॉडाउन जमा होने से पहले एक्सपोज़र काट देते हैं।

प्रत्येक पैटर्न एक विशिष्ट कार्य को बदल देता है जिसके लिए पहले PhD की आवश्यकता होती थी। साथ में वे अधिकांश चीज़ों को बदल देते हैं जो एक शोध टीम वास्तव में दिन-प्रतिदिन करती है।

भाग 6: पांच विफलता मोड जो 90 प्रतिशत खुदरा प्रयासों को मार देते हैं

विफलता 1: वैलिडेटर को छोड़ना।

आपको सुंदर Sharpe अनुपात और बिना किसी कठोरता के 100 सिग्नल मिलेंगे। हर एक छिपा हुआ डेटा स्नूपिंग है।

वैलिडेटर गैर-परक्राम्य है। अपने सबसे मजबूत मॉडल का उपयोग करें। कठोर अस्वीकृति सीमाएँ निर्धारित करें। निर्माता को कभी भी अपने स्वयं के काम को मान्य न करने दें।

विफलता 2: कोई राज्य स्थिरता नहीं।

बिना मेमोरी वाला झुंड हर दिन उसी असफल परिकल्पना का परीक्षण करता है।

प्रत्येक अस्वीकृत सिग्नल को सटीक अस्वीकृति कारण के साथ लॉग किया जाना चाहिए ताकि कोई भी एजेंट कभी भी उसी विफलता पर दोबारा टोकन बर्बाद न करे।

विफलता 3: कोई निर्माता-परीक्षक विभाजन नहीं।

जिस एजेंट ने परिकल्पना उत्पन्न की, वह यह तय करने के लिए सबसे खराब संभव न्यायाधीश है कि क्या यह वास्तविक अल्फा है।

निर्माता और परीक्षक को विभिन्न मॉडलों पर विभिन्न एजेंटों में विभाजित करें। Renaissance ऐसा करता है। Two Sigma ऐसा करता है। Citadel ऐसा करता है। आपके झुंड को भी करना चाहिए।

विफलता 4: एक एजेंट सब कुछ कर रहा है।

जिस क्षण आप एक एजेंट को उत्पन्न करने, इंजीनियर करने, बैकटेस्ट करने और मान्य करने का प्रयास करते हैं, गुणवत्ता ढह जाती है।

विशेषज्ञता ही झुंड को काम करती है। प्रत्येक एजेंट एक काम पूरी तरह से करता है।

विफलता 5: लूप पर कोई रोक शर्त नहीं।

बिना वास्तविक रुकावट वाला लूप चुपचाप विफल हो जाता है। एजेंट एक पूर्णता संकेत उत्सर्जित करता है यह मानते हुए कि कार्य पूरा हो गया है। खराब परिणाम बिना सुधारे पड़े रहते हैं।

प्रत्येक रोक शर्त एजेंट के स्वयं के दावे के अलावा किसी और चीज़ द्वारा जाँचने योग्य होनी चाहिए। "पिछले 30 आउट-ऑफ-सैंपल ट्रेडों पर Sharpe 1.5 से ऊपर।" "ड्रॉडाउन 5 प्रतिशत से नीचे।" कभी नहीं "एजेंट कहता है कि यह हो गया है।"

इन पांचों का सम्मान करें और झुंड संस्थागत-ग्रेड शोध आउटपुट तैयार करता है।

सारांश

अल्फा शोध पहले से ही एक पाइपलाइन है। छह चरण। पेपर पढ़ें। फीचर इंजीनियर करें। बैकटेस्ट करें। मान्य करें। शासनों की जाँच करें। कारकों के विरुद्ध विघटित करें।

हर गंभीर फंड इसे 100 PhD के साथ चलाता है।

छह विशिष्ट AI एजेंटों का एक झुंड आपके लिए हर चरण चलाता है। प्रत्येक एजेंट वह मॉडल चुनता है जो उसकी जटिलता के अनुकूल हो। पूरा झुंड एक Slate Program पर चलता है जो हर 24 घंटे में फायर करता है।

Slate द्वारा Programs वह परत है जो इसे छह महीने के बजाय एक सप्ताहांत में वास्तव में शिप करने योग्य बनाती है।

यह आपके साथ लूप का मसौदा तैयार करता है। यह लूप को सहेजता है। यह लूप को चलाता है। यह इसे हमेशा के लिए चलाता है।

आप पाइपलाइन बनना बंद कर देते हैं। आप वास्तुकार बन जाते हैं।

बुनियादी ढांचे की खाई वास्तविक है। शोध की खाई मर चुकी है।

यही बात है।

यदि आप इसे आज़माना चाहते हैं, तो

https://randomlabs.ai पर साइन अप करें और

@wearerandomlabs को लॉन्च के लिए फॉलो करें।

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

यह झुंड उस प्रणाली का शोध आधा है।

https://x.com/RohOnChain/status/2069056530960490835

जो फंड इसे पहले बनाएंगे, वे अगले दशक के लिए चक्रवृद्धि करेंगे।

जो अभी भी एक समय में एक परिकल्पना चला रहे हैं, वे पीछे छूट जाएंगे।

तो यहाँ वह प्रश्न है जिस पर विचार करना है।

क्या आप वह शोधकर्ता हैं जो अभी भी प्रति सप्ताह एक परिकल्पना का परीक्षण कर रहा है, या क्या आप वह वास्तुकार हैं जिसने वह झुंड बनाया है जो आपके सोते समय हर रात सौ का परीक्षण करता है?

कोई गलत उत्तर नहीं है। लेकिन बहुत ही प्रकट करने वाले हैं।