ग्राफ इंजीनियरिंग का उपयोग करके मल्टी-फैक्टर अल्फा मॉडल कैसे बनाएं

मैं पूरी तरह से समझ गया हूँ कि आपको क्या चाहिए। मैं दिए गए सभी नियमों और दिशानिर्देशों का पालन करते हुए इस अंग्रेजी टेक्स्ट का हिंदी में अनुवाद करूंगा।

यह रहा हिंदी अनुवाद:

मैं विस्तार से बताने जा रहा हूँ कि ग्राफ़ इंजीनियरिंग का उपयोग करके हेज फंड ग्रेड का मल्टी-फैक्टर अल्फा मॉडल कैसे बनाया जाता है।

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

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

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

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

कुछ बिल्डर पहले से ही मेरे साथ इस प्रक्रिया में गहराई से जुड़े हुए हैं। यह ऑफर अभी भी खुला है।

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

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

मल्टी-फैक्टर इन्वेस्टिंग वह तरीका है जिससे वॉल स्ट्रीट का हर गंभीर हेज फंड रिटर्न जनरेट करता है। वे एक ही आइडिया पर ट्रेड नहीं करते। वे फैक्टर्स को स्टैक करते हैं।

यह वही प्रक्रिया है जो AQR चलाता है। वही प्रक्रिया जो Two Sigma चलाता है। वही प्रक्रिया जो Bridgewater चलाता है। और यह पहली बार है जब इसे एक अकेला बिल्डर निष्पादित कर सकता है।

समस्या हमेशा यह रही है कि इसे बनाने के लिए एक रिसर्च टीम की आवश्यकता होती थी। फैक्टर इंजीनियर। सांख्यिकीविद्। पोर्टफोलियो निर्माण विशेषज्ञ। जोखिम विश्लेषक। निष्पादन इंजीनियर। आपको प्रति फैक्टर परिवार कम से कम दस लोगों की ज़रूरत होती है, और कोई अकेला क्वांट वह टीम नहीं बना सकता।

यही कारण है कि रिटेल क्वांट्स सिंगल स्ट्रैटेजी पर अटके रहते हैं और हेज फंड्स अल्फा प्रिंट करते हैं। अब तक।

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

अपने पिछले दो लेखों में मैंने लूप इंजीनियरिंग और AI एजेंटों का झुंड बनाने के बारे में बताया था जो 24/7 अल्फा का शिकार करता है।

एक बार जब आपके पास लूप और झुंड हों, तो वह परत जो उन्हें एक काम करने वाली प्रणाली के रूप में एक साथ रखती है, वह एक ग्राफ़ है।

ग्राफ़ इंजीनियरिंग उस परत को डिज़ाइन करने की प्रैक्टिस है। आप नोड्स को परिभाषित करते हैं। आप एजेज को परिभाषित करते हैं। ग्राफ़ अपने आप चलता है।

इस लेख के अंत तक आप न केवल ग्राफ़ इंजीनियरिंग को समझ जाएंगे।

आपके पास एक स्व-चालित मल्टी-फैक्टर अल्फा मॉडल होगा जो हर 24 घंटे में आपके लैपटॉप पर चलेगा।

भाग 1: ग्राफ़ इंजीनियरिंग वास्तव में क्या है

AI के साथ काम करने वाला हर क्वांट एक ही प्रगति पर कहीं न कहीं होता है। यह जानना कि आप कहाँ हैं, यह स्पष्ट करता है कि आगे कहाँ जाना है।

ग्राफ़ इंजीनियरिंग वास्तव में क्या है

चरण 1: प्रॉम्प्ट्स।

आप एक प्रॉम्प्ट टाइप करते हैं। आप इंतज़ार करते हैं। आप आउटपुट पढ़ते हैं। आप अगला टाइप करते हैं। आप ही लूप हैं। जब आप लैपटॉप बंद करते हैं तो कुछ भी नहीं बचता।

चरण 2: लूप्स।

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

चरण 3: झुंड (स्वार्म्स)।

आप लूप को विशेष भूमिकाओं वाले कई एजेंटों में फैलाते हैं। एक सिग्नल जनरेट करता है। एक उन्हें मान्य करता है। एक निष्पादित करता है। यह वही है जो AI एजेंटों के झुंड वाले लेख ने सिखाया। कई एजेंट समानांतर में, Python ग्लू कोड के माध्यम से हाथ से समन्वित।

चरण 4: ग्राफ़।

आप एक बार समन्वय संरचना का वर्णन करते हैं। नोड्स एजेंट हैं। एजेज डेटा हैंड-ऑफ हैं। ग्राफ़ जानता है कि कब समानांतर करना है, कब इंतज़ार करना है, कब पुनः प्रयास करना है, कब एस्केलेट करना है। आप फिर से ग्लू कोड को नहीं छूते।

ग्राफ़ इंजीनियरिंग उस समन्वय संरचना को डिज़ाइन करने की प्रैक्टिस है।

ग्राफ़ एक स्क्रिप्ट नहीं है। यह अंतर कोई नहीं बताता, लेकिन यह मायने रखता है।

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

विफलता की दीवार ने मुझे तोड़ दिया। जब मेरा लाभप्रदता एजेंट इसलिए ब्लॉक हो गया क्योंकि उसे 500 बैलेंस शीट पार्स करनी थीं और रेट लिमिट हिट करनी थी, तो पूरी पाइपलाइन मर गई।

मैं अगली सुबह एक रुकी हुई प्रक्रिया, कोई सिग्नल नहीं, और यह पता नहीं कि विफलता कहाँ से शुरू हुई, के साथ लौटता था। डिबगिंग का मतलब था स्टैक ट्रेस पढ़ना और अनुमान लगाना कि क्रैश के ऊपर कौन सा एजेंट था।

दूसरे महीने तक मैंने रिसर्च करने से ज्यादा समय कोऑर्डिनेशन डिबग करने में बिताया था। मैं पूरे प्रोजेक्ट को टालने के कगार पर था।

यह वह विफलता की स्थिति है जो हर मल्टी-एजेंट क्वांट को मिलती है। और यही कारण है कि ग्राफ़ मौजूद हैं।

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

यही ग्राफ़ इंजीनियरिंग का वादा है। अब सवाल यह है कि ग्राफ़ को क्या चलाता है।

भाग 2: वह टूल जो ग्राफ़ को चलाता है

ग्राफ़ आर्किटेक्चरल डायग्राम हैं। वे अपने आप नहीं चलते। उन्हें एक रनटाइम चाहिए।

रनटाइम वह जगह है जहाँ ज़्यादातर लोग मल्टी-एजेंट सिस्टम बनाते समय गलती करते हैं।

वे मानते हैं कि मुश्किल हिस्सा ग्राफ़ को डिज़ाइन करना है। ऐसा नहीं है। मुश्किल हिस्सा ऐसा इंफ्रास्ट्रक्चर ढूंढना है जो वास्तव में इसे निष्पादित कर सके।

मैंने एक मल्टी-फैक्टर ग्राफ़ को एंड-टू-एंड चलाने में सक्षम इंफ्रास्ट्रक्चर खोजने से पहले हफ्तों तक अलग-अलग रनटाइम आज़माए।

जो मैं उपयोग करता हूँ उसे Slate कहा जाता है। @wearerandomlabs द्वारा बनाया गया। आपके टर्मिनल में चलता है। आपकी मौजूदा मॉडल सब्सक्रिप्शन उठाता है और उनमें काम फैलाता है।

इस लेख के लिए जो मायने रखता है वह एक क्षमता है जिसे उन्होंने हाल ही में प्रोग्राम्स नाम से जारी किया है। एक प्रोग्राम एक ग्राफ़ है जो JavaScript में लिखा जाता है जिसे Slate आपके लिए लगातार चलाता है।

एक प्रॉम्प्ट एक बार चलता है और रुक जाता है। एक प्रोग्राम तब तक चलता रहता है जब तक काम पूरा नहीं हो जाता।

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

Slate फिर आपको एक डायग्राम दिखाता है। आप डायग्राम के बारे में सवाल पूछते हैं। आप नोड्स बदलते हैं। आप मॉडल्स को एडजस्ट करते हैं। केवल जब आप संतुष्ट होते हैं, तब आप Slate को सेव करके चलाने के लिए कहते हैं।

यदि यह टूटता है, तो आप Slate के साथ विफलता के बारे में चैट करते हैं। Slate ग्राफ़ को पैच करता है।

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

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

उन्हें कहा जाता है

/goal

और

/deepresearch

।

/goal - ग्राफ़ जो सत्यापित रूप से पूरा होने तक चलते हैं

Slate के अंदर यह टाइप करें:

1/goal Python में एक Newey-West एडजस्टेड t-स्टैटिस्टिक फंक्शन लागू करें और सत्यापित करें कि यह दस यादृच्छिक रिटर्न श्रृंखलाओं पर statsmodels के कार्यान्वयन से मेल खाता है

Slate एक मॉडल पर एक प्रॉम्प्ट फायर नहीं करता। यह एक ग्राफ़ स्पिन करता है।

**एक नोड फंक्शन लिखता है। दूसरा सत्यापन परीक्षण लिखता है। तीसरा दोनों को चलाता है। चौथा ग्रेड करता है कि क्या आउटपुट मेल खाते हैं।**

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

यह रनटाइम में मेकर-चेकर पैटर्न है। मेकर कभी भी मेकर के अपने काम को ग्रेड नहीं करता।

/deepresearch - ग्राफ़ जो रिसर्च को समानांतर करते हैं

Slate के अंदर यह प्रयास करें:

1/deepresearch नवीनतम अकादमिक शोध 2015 से 2026 तक उभरते बाजारों में Fama-French पांच-फैक्टर मॉडल के आउट-ऑफ-सैंपल प्रदर्शन के बारे में क्या कहता है

यहाँ जो ग्राफ़ स्पिन होता है वह /goal से अलग है।

यह एक समानांतर रिसर्च फैनआउट है।

Slate एक साथ कई वर्कर एजेंट भेजता है। प्रत्येक प्रश्न के एक अलग कोण को संभालता है।

एक हालिया पेपर पढ़ता है। दूसरा arXiv q-fin चेक करता है। दूसरा Kenneth French लाइब्रेरी से डेटा खींचता है। दूसरा उद्धरणों को क्रॉस-रेफरेंस करता है।

वे सभी एक केंद्रीय ऑर्केस्ट्रेटर को रिपोर्ट करते हैं जो निष्कर्षों को संश्लेषित करता है।

/deepresearch इस बिल्ड के लिए मायने रखने का कारण यह है कि यह उस सटीक पैटर्न को प्रदर्शित करता है जिसकी आपको फैक्टर निर्माण के लिए आवश्यकता है।

सात फैक्टर एजेंट। प्रत्येक एक अलग फैक्टर का मालिक है। सभी समानांतर में चल रहे हैं। सभी एक केंद्रीय ऑर्केस्ट्रेटर को रिपोर्ट कर रहे हैं।

यह मल्टी-फैक्टर ग्राफ़ है, जिसमें क्वांट-विशिष्ट कार्य शामिल नहीं हैं।

उन प्रश्नों पर /goal और /deepresearch चलाने में 30 मिनट बिताएँ जिनकी आप वास्तव में परवाह करते हैं। इस तरह ग्राफ़ इंजीनियरिंग अंतर्ज्ञान होता है।

भाग 3: मल्टी-फैक्टर अल्फा ग्राफ़

मल्टी-फैक्टर इन्वेस्टिंग स्टॉक रिटर्न को व्यवस्थित ड्राइवरों और एक अवशिष्ट में विघटित करता है। मूलभूत संस्करण Fama French तीन-फैक्टर मॉडल है, जो 1993 में प्रकाशित हुआ:

R_i स्टॉक i पर रिटर्न है। R_f जोखिम-मुक्त दर है। R_m बाजार रिटर्न है। SMB साइज़ प्रीमियम है। HML वैल्यू प्रीमियम है।

अल्फा α वह है जो मॉडल समझा नहीं सकता। वह अवशिष्ट वही है जिसका आप शिकार कर रहे हैं।

Carhart ने 1997 में मोमेंटम जोड़ा। Fama और French ने 2015 में लाभप्रदता (RMW) और निवेश (CMA) जोड़ा।

आधुनिक हेज फंड सात-फैक्टर स्टैक चलाते हैं। AQR, Two Sigma, Millennium, Bridgewater सभी वेरिएंट चलाते हैं। यहाँ सात फैक्टर हैं जो 2026 में मायने रखते हैं।

फैक्टर 1: मार्केट बीटा।

स्टॉक अतिरिक्त रिटर्न का बाजार अतिरिक्त रिटर्न के खिलाफ रोलिंग 60 महीने का रिग्रेशन।

फैक्टर 2: साइज़ (SMB)।

छोटी कंपनियां बड़ी कंपनियों की तुलना में जोखिम-समायोजित आधार पर बेहतर प्रदर्शन करती हैं।

फैक्टर 3: वैल्यू (HML)।

उच्च बुक-टू-मार्केट कम बुक-टू-मार्केट की तुलना में लंबी अवधि में बेहतर प्रदर्शन करता है।

फैक्टर 4: मोमेंटम (MOM)।

हाल के 12 महीनों के विजेता 3 से 12 महीनों तक जीतते रहते हैं।

फैक्टर 5: लाभप्रदता (RMW)।

मजबूत संचालक कमजोर संचालकों से बेहतर प्रदर्शन करते हैं।

फैक्टर 6: निवेश (CMA)।

रूढ़िवादी परिसंपत्ति वृद्धि आक्रामक विस्तार से बेहतर प्रदर्शन करती है।

फैक्टर 7: कम अस्थिरता।

कम अस्थिरता वाले स्टॉक सिद्धांत की भविष्यवाणी से अधिक जोखिम-समायोजित रिटर्न अर्जित करते हैं।

हर फंड इसका एक संस्करण चलाता है। अकेले बिल्डर नहीं कर सकते क्योंकि इसके लिए एक रिसर्च टीम चाहिए।

ग्राफ़ इंजीनियरिंग इसे हल करती है। प्रत्येक फैक्टर एक नोड बन जाता है।

यहाँ पूरा ग्राफ़ है। कुल ग्यारह नोड्स।

फैक्टर निर्माण नोड्स (समानांतर में चलते हैं)

नोड 1: मार्केट बीटा एजेंट।

रोलिंग 60 महीने का रिग्रेशन चलाता है। प्रत्येक स्टॉक के लिए बीटा आउटपुट करता है।

नोड 2: साइज़ एजेंट।

मार्केट कैप के अनुसार सॉर्ट करता है। छोटे-बड़े स्प्रेड की गणना करता है।

नोड 3: वैल्यू एजेंट।

बुक-टू-मार्केट के अनुसार सॉर्ट करता है। उच्च-निम्न स्प्रेड की गणना करता है।

नोड 4: मोमेंटम एजेंट।

12 माइनस 1 महीने के मोमेंटम की गणना करता है। डेसाइल स्प्रेड से MOM का निर्माण करता है।

नोड 5: लाभप्रदता एजेंट।

सकल लाभप्रदता की गणना करता है। RMW का निर्माण करता है।

नोड 6: निवेश एजेंट।

वार्षिक परिसंपत्ति वृद्धि की गणना करता है। CMA का निर्माण करता है।

नोड 7: कम अस्थिरता एजेंट।

पिछले 60 दिनों की वास्तविक अस्थिरता की गणना करता है। डेसाइल स्प्रेड से कम अस्थिरता का निर्माण करता है।

समन्वय नोड्स (क्रम में चलते हैं)

नोड 8: वैलिडेटर।

प्रत्येक फैक्टर पर Newey-West एडजस्टेड t स्टैटिस्टिक्स चलाता है। बूटस्ट्रैप 10,000 पुनरावृत्तियों को रीसैंपल करता है। किसी भी फैक्टर को मार देता है जिसमें इन-सैंपल बनाम आउट-ऑफ-सैंपल गिरावट 30 प्रतिशत से ऊपर हो।

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

नोड 9: रेजीम ऑडिटर।

अस्थिरता और रिटर्न पर एक हिडन मार्कोव मॉडल का उपयोग करके 20 साल के इतिहास को तीन रेजीम में विभाजित करता है। किसी भी चीज़ को मार देता है जो केवल एक रेजीम में काम करती है।

नोड 10: पोर्टफोलियो कंस्ट्रक्टर।

जीवित फैक्टर्स को जोखिम समता भार का उपयोग करके एक लॉन्ग-शॉर्ट पोर्टफोलियो में जोड़ता है। सेक्टर, बीटा और डॉलर तटस्थता लागू करता है।

नोड 11: जोखिम डीकंपोजर।

पोर्टफोलियो को सात फैक्टर्स और स्टाइल और मैक्रो फैक्टर्स के खिलाफ रिग्रेस करता है। अवशिष्ट अल्फा और t स्टैटिस्टिक रिपोर्ट करता है।

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

ग्यारह नोड्स। प्रत्येक का अपना एक काम है। वे अपने आउटपुट को ग्राफ़ के नीचे पास करते हैं।

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

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

यहाँ सटीक बिल्ड है। अपने टर्मिनल में साथ चलें।

चरण 1: Slate इंस्टॉल करें

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

1npm i -g @randomlabs/slate

Slate एक वैश्विक npm पैकेज है। इंस्टॉल होने में लगभग 30 सेकंड लगते हैं।

इसके साथ सत्यापित करें:

1slate --version

चरण 2: अपनी प्रोजेक्ट डायरेक्टरी बनाएं

मल्टी-फैक्टर रिसर्च को अपने स्वयं के वर्कस्पेस की आवश्यकता होती है। स्टेट फ़ाइलें, ऐतिहासिक फैक्टर परीक्षण, पोर्टफोलियो स्नैपशॉट सभी यहाँ रहते हैं।

1mkdir ~/projects/multifactor-alpha
2cd ~/projects/multifactor-alpha

एक ही फ़ोल्डर से अन्य Slate प्रोजेक्ट न चलाएँ। स्टेट नेमस्पेसिंग प्रति वर्कस्पेस है।

चरण 3: Slate लॉन्च करें

टाइप करें:

1slate

चरण 4: अपने प्रोवाइडर्स कनेक्ट करें

Slate के अंदर, टाइप करें:

1/providers

यह प्रोवाइडर कॉन्फ़िगरेशन स्क्रीन खोलता है। Random Labs डिफ़ॉल्ट रूप से प्रमाणित करता है। आप OpenAI Codex और GitHub Copilot को भी सीधे कनेक्ट कर सकते हैं।

एरो कीज़ के साथ Codex पर नेविगेट करें और प्रमाणित करने के लिए एंटर दबाएँ। आपकी मौजूदा सब्सक्रिप्शन काम करेगी।

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

Slate के अंदर, टाइप करें:

1/models

आप हर कनेक्टेड प्रोवाइडर पर उपलब्ध हर मॉडल देखते हैं। Random Labs लगभग 90 मॉडल होस्ट करता है।

आपको दो मॉडल टियर चाहिए।

सात फैक्टर निर्माण एजेंटों के लिए एक तेज़ टियर। Claude Sonnet काम करता है।

वैलिडेटर, रेजीम ऑडिटर और जोखिम डीकंपोजर के लिए एक मजबूत रीज़निंग टियर। Claude Opus काम करता है।

चरण 6: /goal और /deepresearch के साथ वार्म अप करें

अपना खुद का प्रोग्राम तैयार करने से पहले, दो शिप किए गए उदाहरण प्रोग्राम्स के साथ 30 मिनट बिताएँ।

इस तरह ग्राफ़ इंजीनियरिंग एक अवधारणा नहीं रह जाती और अंतर्ज्ञान बन जाती है।

Slate के अंदर यह /goal कमांड आज़माएँ:

1/goal एक Python फंक्शन लिखें जो Fama-MacBeth क्रॉस-सेक्शनल रिग्रेशन गुणांक की गणना करता है और सत्यापित करें कि यह 20 साल के मासिक रिटर्न डेटा पर empiricalfin पैकेज से मेल खाता है

देखें कि ग्राफ़ कैसे फैलता है। देखें कि ग्रेडर मॉडल राइटर मॉडल के काम की जाँच कैसे करता है। देखें कि जब पहला प्रयास विफल होता है तो क्या होता है।

फिर यह /deepresearch कमांड आज़माएँ:

1/deepresearch अकादमिक साहित्य लाभप्रदता फैक्टर RMW बनाम MSCI द्वारा परिभाषित गुणवत्ता फैक्टर के बारे में क्या कहता है और वे 2015 से 2026 तक अनुभवजन्य रूप से कैसे भिन्न हैं

समानांतर वर्कर फैनआउट देखें। ऑर्केस्ट्रेटर को संश्लेषित करते हुए देखें।

ये दो रन आपको वह मानसिक मॉडल देते हैं जिसकी आपको अपना खुद का प्रोग्राम लिखने से पहले आवश्यकता है।

चरण 7: मल्टी-फैक्टर प्रोग्राम का ड्राफ्ट तैयार करें

यह सबसे महत्वपूर्ण कदम है। आप ग्राफ़ का सादे अंग्रेजी में वर्णन करते हैं और Slate इसे आपके साथ तैयार करता है।

Slate में यह सटीक प्रॉम्प्ट टाइप करें:

1मेरे लिए एक प्रोग्राम तैयार करें जो सात मल्टी-फैक्टर रिसर्च एजेंटों को समानांतर में चलाता है:
2मार्केट बीटा, साइज़, वैल्यू, मोमेंटम, लाभप्रदता, निवेश, और कम अस्थिरता।
3सभी सात पूरे होने के बाद, क्रम में एक वैलिडेटर, एक रेजीम ऑडिटर, एक पोर्टफोलियो
4कंस्ट्रक्टर और एक जोखिम डीकंपोजर चलाएँ। सात फैक्टर एजेंटों के लिए Claude Sonnet और
5वैलिडेटर, रेजीम ऑडिटर और जोखिम डीकंपोजर के लिए Claude Opus का उपयोग करें।
6पूरी पाइपलाइन हर 24 घंटे में चलाएँ। मेमोरी के रूप में फ़ाइल सिस्टम का उपयोग करें।
7प्रति रन $30 का बजट सेट करें। Newey-West t-स्टैट 2.5 से ऊपर लागू करें, बूटस्ट्रैप 10,000 पुनरावृत्तियाँ,
8और इन-सैंपल बनाम आउट-ऑफ-सैंपल शार्प गिरावट 30 प्रतिशत से ऊपर होने पर किसी भी फैक्टर को अस्वीकार करें।

Slate सिर्फ़ कोड लिखना शुरू नहीं करता। यह ध्यान से पढ़ता है और स्पष्ट प्रश्न पूछता है।

कौन सा डेटा स्रोत। कौन सा बैकटेस्ट विंडो। कौन सा यूनिवर्स। कौन सा रेजीम क्लासिफायर। क्या ओवरराइड करने योग्य डिफ़ॉल्ट का उपयोग करना है।

आप सादे अंग्रेजी में जवाब देते हैं। Slate JavaScript लिखता है।

चरण 8: ग्राफ़ डायग्राम की समीक्षा करें

एक बार जब Slate ने प्रोग्राम तैयार कर लिया, तो यह ग्राफ़ का एक डायग्राम प्रस्तुत करता है।

आप यह समझने के लिए कोड नहीं पढ़ रहे हैं कि क्या चलेगा। आप समन्वय संरचना देख रहे हैं।

ऑर्केस्ट्रेटर से समानांतर में चलने वाले सात फैक्टर नोड्स। एक सिंक पॉइंट। क्रम में चार समन्वय नोड्स। एक पर्सिस्टेंस स्टेप। एक स्लीप नोड। शीर्ष पर वापस एक लूप।

कुछ भी चलाने से पहले Slate से डायग्राम के बारे में प्रश्न पूछें:

• वैलिडेटर Opus पर क्यों चल रहा है?
• क्या होता है यदि मोमेंटम एजेंट टाइम आउट हो जाता है?
• चक्रों के बीच कौन सी स्टेट बनी रहती है?
• रेजीम ऑडिटर को किसी फैक्टर को अस्वीकार करने के लिए क्या ट्रिगर करता है?

यदि कोई उत्तर आपको आश्चर्यचकित करता है, तो Slate से ग्राफ़ बदलने के लिए कहें।

चरण 9: सेव करें और चलाएँ

एक बार जब डायग्राम आपकी इच्छा से मेल खाता है, तो Slate को प्रोग्राम को एक फ़ाइल में कमिट करने के लिए कहें। फिर चलाएँ:

1slate run multifactor-alpha.js

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

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

पहले रन में 15 से 25 मिनट लगते हैं। बाद के दैनिक रन तेज़ होते हैं क्योंकि स्टेट फ़ाइल में पहले से ही इतिहास होता है।

चरण 10: एक बजट सेट करें

Slate के अंदर, टाइप करें:

1/budget $30/run

यह प्रति रन कुल खर्च को सीमित करता है। यदि कोई रन सीमा के करीब पहुँचता है, तो Slate जारी रखने से पहले एस्केलेट करता है।

चरण 11: जब यह टूटे तो डिबग करें

असली प्रोग्राम टूटते हैं। मेरा पहले दो हफ्तों में तीन बार टूटा।

वैल्यू एजेंट इसलिए ब्लॉक हो गया क्योंकि वह गैर-अमेरिकी बैलेंस शीट की व्याख्या नहीं कर सका। मैंने Slate को बताया। Slate ने वैल्यू एजेंट में एक मुद्रा सामान्यीकरण चरण जोड़ा।

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

पोर्टफोलियो कंस्ट्रक्टर ने कभी-कभी सेक्टर तटस्थता का उल्लंघन किया। मैंने Slate को बताया। Slate ने पोर्टफोलियो लिखने से पहले तटस्थता लागू करने के लिए एक प्रोजेक्शन चरण जोड़ा।

आप स्टैक ट्रेस का पीछा नहीं करते। आप Slate को समस्या का वर्णन करते हैं। Slate नोड को पैच करता है।

भाग 5: जब मैंने इसे चलाया तो वास्तव में क्या हुआ

यहाँ वह हिस्सा है जिसकी मुझे उम्मीद नहीं थी।

मैंने Slate को एक पैराग्राफ में ग्राफ़ का वर्णन किया। Slate ने पहले उपलब्ध मॉडल पहचानकर्ताओं की जाँच की, मॉडल्स स्किल को सक्रिय किया, और तेज़ एजेंटों के लिए claude-sonnet-4.6 और समन्वय चरणों के लिए claude-opus-4.5 को चुना।

फिर Slate ने एक बार में पूरा प्रोग्राम तैयार किया। एक मोटा ड्राफ्ट नहीं। पूरा JavaScript। ग्यारह नोड्स एक साथ वायर्ड। समानांतर फैक्टर निर्माण। अनुक्रमिक सत्यापन। टाइमस्टैम्प्ड रन डायरेक्टरीज के साथ फाइलसिस्टम शेयर्ड मेमोरी। बजट आवंटन। पूरी चीज़।

Slate ने सिर्फ़ कोड लिखा और गायब नहीं हुआ। यह तीन विशिष्ट निर्णयों के साथ वापस आया जिन्हें वह चलाने से पहले पुष्टि करना चाहता था।

निर्णय 1: पोर्टफोलियो कंस्ट्रक्टर मॉडल। मेरे ड्राफ्ट प्रॉम्प्ट ने वैलिडेटर, रेजीम ऑडिटर और जोखिम डीकंपोजर के लिए Opus निर्दिष्ट किया था, लेकिन मैंने पोर्टफोलियो कंस्ट्रक्टर के लिए कोई मॉडल नाम नहीं दिया था। Slate ने इसे डिफ़ॉल्ट रूप से Opus पर सेट कर दिया क्योंकि यह चरण भारी विश्लेषणात्मक काम है, लेकिन इसे एक फ्लिप के रूप में चिह्नित किया यदि मैं Sonnet चाहता था।

निर्णय 2: मॉडल संस्करण। Slate ने वर्तमान स्थिर Sonnet और Opus (4.6 और 4.5) का उपयोग किया और यदि मैं चाहूँ तो नए संस्करणों में अपग्रेड करने की पेशकश की।

निर्णय 3: बजट प्रवर्तन। इसने मुझे आश्चर्यचकित किया। Slate ने मुझे स्पष्ट रूप से बताया कि प्रति रन $30 की सीमा एक सलाहकारी थी, हार्ड किल स्विच नहीं। कोई रियल-टाइम लागत मीटरिंग प्रिमिटिव नहीं है, इसलिए बजट को एक बताई गई सीमा और स्व-रिपोर्ट किए गए खर्च के रूप में लागू किया जाता है जिसे जोड़ा और चिह्नित किया जाता है। यदि मैं रन के बीच में हार्ड एबॉर्ट चाहता था, तो Slate ने इसे स्पष्ट रूप से डिज़ाइन करने की पेशकश की।

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

मैंने तीनों डिफ़ॉल्ट की पुष्टि की, प्रोग्राम का नाम बदलकर multifactor-research-pipeline रखा और Slate को इसे कमिट करने के लिए कहा।

फिर मैंने रन दबाया।

सात फैक्टर एजेंट तुरंत फायर हो गए। प्रत्येक अपने स्वयं के सबएजेंट आईडी और स्टेटस टाइमर के साथ टर्मिनल में दिखाई दिया।

Slate ने सादे अंग्रेजी में रन की पुष्टि की:

"यह बैकग्राउंड में multifactor-pipeline के रूप में चल रहा है, Sonnet पर समानांतर में सात फैक्टर एजेंटों से शुरू होकर, फिर Opus पर वैलिडेटर → रेजीम → पोर्टफोलियो → जोखिम अनुक्रम, डिफ़ॉल्ट (./research-memory, $30 बजट, तीन गेट्स, सतत 24-घंटे का लूप) के साथ।"

वह एक पंक्ति बताती है कि ग्राफ़ स्क्रिप्ट को क्यों हराते हैं।

मैंने कोऑर्डिनेशन कोड नहीं लिखा। मैंने स्टैक ट्रेस का पीछा नहीं किया। मैंने APIs को एक साथ गोंद नहीं किया। मैंने ग्राफ़ का सादे अंग्रेजी में वर्णन किया, तीन डिज़ाइन प्रश्नों का उत्तर दिया, और Slate ने इसे बनाया।

लॉन्च पर सब कुछ ओवरराइड करने योग्य है। अंतराल, बजट, गेट थ्रेशोल्ड, मॉडल, मेमोरी लोकेशन, और एक maxRuns कैप यदि आप नहीं चाहते कि ग्राफ़ हमेशा के लिए चले।

यहाँ पूरा प्रोग्राम है जो Slate ने मेरे लिए लिखा था। इसका अध्ययन करें, लेकिन इसे शब्दशः कॉपी न करें। आपका Slate के स्पष्ट प्रश्नों के आपके उत्तरों के आधार पर थोड़ा अलग दिखेगा।

भाग 6: हर 24 घंटे में क्या होता है

आपके समयानुसार सुबह 3 बजे, ग्राफ़ जागता है।

सात फैक्टर एजेंट समानांतर में फायर करते हैं। प्रत्येक पिछले 24 घंटे का नवीनतम मूल्य और मौलिक डेटा खींचता है। अपने फैक्टर टाइम सीरीज़ को अपडेट करता है। वैलिडेटर को सौंपता है।

वैलिडेटर Newey West t टेस्ट चलाता है। 10,000 नमूनों को बूटस्ट्रैप करता है। किसी भी चीज़ को मार देता है जो आउट-ऑफ-सैंपल में विफल रही।

यह अकेला कदम लगभग 80 प्रतिशत उन चीज़ों को अस्वीकार कर देता है जो पहले बैकटेस्ट पर आशाजनक दिखती हैं।

रेजीम ऑडिटर वह लेता है जो बच गया। HMM का उपयोग करके इतिहास को विभाजित करता है। प्रति रेजीम शार्प की पुनर्गणना करता है।

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

पोर्टफोलियो कंस्ट्रक्टर जीवित फैक्टर्स को लेता है। तटस्थता बाधाओं के साथ लॉन्ग-शॉर्ट पोर्टफोलियो बनाता है।

जोखिम डीकंपोजर पोर्टफोलियो को लेता है। इसे व्यापक स्टाइल और मैक्रो फैक्टर सेट के खिलाफ रिग्रेस करता है।

यदि अवशिष्ट अल्फा t स्टैट 2.5 से ऊपर है, तो सिग्नल बच जाता है। यदि नहीं, तो दिन को कोई सिग्नल नहीं के रूप में लॉग किया जाता है और ग्राफ़ कल तक सो जाता है।

हर सुबह आप एक Slack संदेश के साथ जागते हैं। या तो आपके पास एक सिग्नल है जिसका आप ट्रेड कर सकते हैं। या आपके पास दस्तावेजी सबूत है कि आज शोर था।

दोनों परिणाम उपयोगी हैं। किसी के लिए भी आपको कीबोर्ड पर होने की आवश्यकता नहीं थी।

2026 में एक स्व-चालित मल्टी-फैक्टर अल्फा मॉडल ऐसा दिखता है।

खाका

यदि आप और कुछ नहीं याद रखते हैं, तो इन सात चालों को क्रम में याद रखें।

1. प्रगति को समझें। प्रॉम्प्ट्स लूप्स बन गए। लूप्स झुंड बन गए। झुंड ग्राफ़ बन गए।

2. एक रनटाइम चुनें जो ग्राफ़ को निष्पादित कर सके। स्क्रिप्ट टूट जाती हैं। ग्राफ़ चलते हैं। अंतर जानें।

3. सात फैक्टर नोड्स को समानांतर में डिज़ाइन करें। प्रत्येक नोड एक फैक्टर है। प्रत्येक नोड एक नौकरी है। कोई ओवरलैप नहीं।

4. चार समन्वय नोड्स को क्रम में जोड़ें। वैलिडेटर। रेजीम ऑडिटर। पोर्टफोलियो कंस्ट्रक्टर। जोखिम डीकंपोजर।

5. सादी भाषा में वर्णन करें, कोड में नहीं। आप JavaScript नहीं लिखते हैं। आप सादे अंग्रेजी में ग्राफ़ का वर्णन करते हैं। रनटाइम इसे बनाता है।

6. ग्राफ़ से बात करके डिबग करें। जब कोई नोड टूटता है, तो आप स्टैक ट्रेस नहीं पढ़ते। आप समस्या का वर्णन करते हैं। रनटाइम नोड को पैच करता है।

7. इसे हर 24 घंटे में चलने दें। हर सुबह एक सिग्नल या सबूत कि कोई सिग्नल नहीं था। दोनों ही विजय हैं।

बाकी सब शोर है।

यह हिंदी अनुवाद है। कृपया मुझे बताएं यदि आपको किसी भी भाग में समायोजन की आवश्यकता है।

2. अपने कारकों को जानें। बाजार, आकार, मूल्य, गति, लाभप्रदता, निवेश, कम अस्थिरता। सात कारक। प्रत्येक एक नोड बन जाता है।

3. ग्यारह नोड डिज़ाइन करें। समानांतर में सात फैक्टर एजेंट। क्रम में चार समन्वय एजेंट। कोड की एक पंक्ति लिखने से पहले ग्राफ बनाएं।

4. विभिन्न नोड्स के लिए अलग-अलग मॉडल का उपयोग करें। फैक्टर निर्माण के लिए Sonnet। सत्यापन और विघटन के लिए Opus। निर्माता कभी भी निर्माता को मान्य नहीं करता।

5. कड़े नियम लागू करें। Newey West t आँकड़ा 2.5 से ऊपर। 10,000 पुनरावृत्तियों के लिए Bootstrap। तीन HMM अवस्थाओं में शासन मजबूती। अवशिष्ट अल्फा t आँकड़ा 2.5 से ऊपर।

6. /goal और /deepresearch के साथ वार्म अप करें। ग्राफ़ इंजीनियरिंग अंतर्ज्ञान ग्राफ़ देखने से आता है, उनके बारे में पढ़ने से नहीं।

7. इसे संयोजित होने दें। पहला महीना बग्स ढूंढने का है। दूसरा महीना कारकों को परिष्कृत करने का है। तीसरे महीने तक, आपका ग्राफ़ ऐसे सिग्नल उत्पन्न करेगा जिनका आप वास्तव में व्यापार कर सकते हैं।

अब जाओ और इसे बनाओ

आज रात Slate इंस्टॉल करें। इसे लॉन्च करें। एक वास्तविक क्वांट प्रश्न पर /goal चलाएं। एक ऐसे कारक पर /deepresearch चलाएं जिसके बारे में आप उत्सुक हैं।

फिर चरण 6 के सटीक प्रॉम्प्ट के साथ अपना स्वयं का प्रोग्राम तैयार करें। आरेख की समीक्षा करें। इसे चलाएं। $30 का बजट निर्धारित करें।

अगले सप्ताह के इसी समय तक आपके पास अपना पहला स्वचालित मल्टी-फैक्टर ग्राफ़ होगा।

अगले महीने के इसी समय तक आपके पास अपना पहला ट्रेडेबल सिग्नल होगा जो सभी ग्यारह नोड्स से बच जाएगा।

यही व्यापार है। एक सप्ताहांत की स्थापना एक संयोजित अनुसंधान प्रणाली के लिए जो कभी सोती नहीं है।

अब जाओ और इसे बनाओ।

यदि आप निर्माण के किसी भी भाग में फंस जाते हैं, तो मुझे यहाँ DM करें।

आप Slate को यहाँ पा सकते हैं: http://randomlabs.ai/rr

@wearerandomlabs को फॉलो करें यदि आप उनके द्वारा जारी की जाने वाली हर क्षमता को देखना चाहते हैं। /goal और /deepresearch पहले दो प्रोग्राम हैं। वे अंतिम नहीं होंगे।