न्यूरल नेटवर्क: परसेप्ट्रॉन से डीप लर्निंग तक

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

यह गलती नहीं थी। पचास मूव्स बाद, वह पत्थर — जो अब "मूव 37" के नाम से मशहूर है — वह मोड़ था जिस पर पूरा गेम घूम गया। AlphaGo जीत गया। ली सेडोल, जिन्हें दुनिया के सबसे बेहतरीन खिलाड़ियों में से एक माना जाता है, सीरीज़ 4–1 से हार गए। और अहम बात यह है: किसी इंसान ने AlphaGo को वह मूव नहीं सिखाया था। यह किसी किताब में नहीं था। मशीन ने इसे खुद खोजा, खुद के खिलाफ लाखों गेम खेलकर और अरबों छोटे-छोटे इंटरनल नंबरों को तब तक ठीक करते हुए, जब तक एक पैटर्न उभर नहीं आया जो किसी इंसान ने कभी नहीं देखा था।

Go में जितनी संभव बोर्ड पोज़िशन हैं, उतने परमाणु देखे जाने योग्य ब्रह्मांड में भी नहीं हैं। आप इसे ब्रूट-फोर्स नहीं कर सकते। आप इसके लिए नियम नहीं लिख सकते। इसे सुपरह्यूमन लेवल पर खेलने का एकमात्र तरीका है इसे सीखना — और सीखने वाली चीज़ थी एक न्यूरल नेटवर्क: सरल गणितीय इकाइयों का एक ढेर, जो पर्याप्त डेटा और पर्याप्त ठीक करने पर, ऐसा ढांचा खोज सकता है जिसे कोई इंसान पूरी तरह से बयान नहीं कर सकता।

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

हर न्यूरल नेटवर्क — एक सामान्य स्पैम फिल्टर से लेकर GPT और AlphaGo तक — एक ही विचार से आता है: परसेप्ट्रॉन, जिसे 1958 में फ्रैंक रोज़ेनब्लाट ने बनाया था। यह एक गणितीय मॉडल है जो एक जैविक न्यूरॉन से ढीले तरीके से प्रेरित है। एक असली न्यूरॉन अपने डेंड्राइट्स से विद्युत संकेत प्राप्त करता है, उन्हें सेल बॉडी में जमा करता है, और अपने एक्सॉन के नीचे तभी सिग्नल भेजता है जब जोड़ा गया इनपुट एक सीमा को पार कर जाता है। परसेप्ट्रॉन वही करता है, बस वोल्टेज के बजाय नंबरों के साथ।

एक परसेप्ट्रॉन इनपुट का एक वेक्टर x लेता है, हर इनपुट को एक सीखे गए वेट w से गुणा करता है, प्रोडक्ट्स को जोड़ता है, एक बायस टर्म b जोड़ता है जो सीमा को खिसकाता है, और नतीजे को एक एक्टिवेशन फंक्शन से गुज़ारता है। यदि नतीजा उस बार को पार करता है, तो न्यूरॉन "फायर" होता है; नहीं तो वह शांत रहता है। यह पूरी चीज़ एक कॉम्पैक्ट एक्सप्रेशन में है: output = f(w·x + b)।

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

एक अकेले परसेप्ट्रॉन की एक कठोर सीमा है: यह डेटा को केवल एक सीधी रेखा से अलग कर सकता है (या, ज़्यादा डाइमेंशन में, एक फ्लैट हाइपरप्लेन)। यह "क्या यह बिंदु रेखा के ऊपर या नीचे है?" जवाब दे सकता है, पर "क्या यह बिंदु घुमावदार क्षेत्र के भीतर है?" नहीं। ऐतिहासिक उदाहरण XOR समस्या है — एक पैटर्न जिसे एक अकेला परसेप्ट्रॉन सिद्ध रूप से नहीं सीख सकता, एक सीमा जिसने 1970 के दशक में AI फंडिंग को सालों के लिए जमा दिया। पीछे मुड़कर देखें तो निकलने का रास्ता बेहद सीधा है: कई परसेप्ट्रॉन को लेयर में ढेर करें और उनके बीच एक नॉनलिनियर एक्टिवेशन डालें। ऐसा करें, और नतीजे में मिलने वाला नेटवर्क स्पेस को मोड़, तह, और अत्यधिक जटिल आकारों में तराश सकता है।

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

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

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

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

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

वे एक्टिवेशन जो हर प्रैक्टिशनर को जानने चाहिए:

• Sigmoid — σ(x) = 1/(1+e⁻ˣ)। किसी भी इनपुट को (0, 1) में दबा देता है, जो एक संभावना जैसा स्वाभाविक लगता है। बाइनरी आउटपुट के लिए बढ़िया, पर हिडन लेयर के भीतर एक खराब विकल्प: बड़े पॉज़िटिव या नेगेटिव इनपुट के लिए कर्व फ्लैट हो जाता है, उसका ग्रेडिएंट लगभग शून्य हो जाता है, और सीखना रुक जाता है — यह वैनिशिंग ग्रेडिएंट समस्या है।
• Tanh — आउटपुट (−1, 1) में देता है और ज़ीरो-सेंटर्ड है, जो ऑप्टिमाइज़ेशन में मदद करता है। अभी भी चरम पर सैचुरेट होता है, पर sigmoid से कम बुरी तरह।
• ReLU — f(x) = max(0, x)। हिडन लेयर के लिए आधुनिक डिफॉल्ट। यह हास्यजनक रूप से सरल है, कंप्यूट करना सस्ता है, और सभी पॉज़िटिव इनपुट के लिए एक स्वस्थ ग्रेडिएंट रखता है। इसकी खामी है "डाइंग ReLU": एक न्यूरॉन जिसे हमेशा शून्य आउटपुट देने के लिए धकेल दिया जाता है, वह स्थायी रूप से निष्क्रिय हो सकता है।
• Leaky ReLU — f(x) = max(0.01x, x)। नेगेटिव के लिए ग्रेडिएंट की एक छोटी धार बहने देता है, जो न्यूरॉन्स को मरने से बचाता है।
• GELU — ReLU का एक स्मूथ, प्रोबेबिलिस्टिक कज़िन जो BERT और GPT जैसे ट्रांसफॉर्मर के भीतर स्टैंडर्ड है।

अब तक हमारे पास वेट्स से भरा एक नेटवर्क है। पर सही वेट वैल्यू कहां से आती हैं? कोई उन्हें टाइप नहीं करता — लाखों होती हैं। उन्हें एक फीडबैक लूप के ज़रिए खोजा जाता है जो, अपने मूल में, संगठित ट्रायल एंड एरर है जिसमें बुककीपिंग कैलकुलस करता है।

पहला चरण है फॉरवर्ड पास: एक उदाहरण डालें, इसे लेयर्स से बहने दें, और एक प्रेडिक्शन पढ़ें। दूसरा चरण है यह मापना कि वह प्रेडिक्शन कितनी गलत थी, एक लॉस फंक्शन का उपयोग करते हुए। किसी नंबर (एक प्राइस) को प्रेडिक्ट करने के लिए, Mean Squared Error प्रेडिक्शन और सच के बीच के अंतर के वर्ग का औसत निकालता है। क्लासिफिकेशन के लिए, क्रॉस-एंट्रॉपी मापता है कि प्रेडिक्ट की गई संभावनाएं सही जवाब से कितनी दूर हैं। एक बड़ा लॉस मतलब "बहुत गलत"; ट्रेनिंग का पूरा लक्ष्य उस नंबर को नीचे धकेलना है।

तीसरा चरण चतुर हिस्सा है: बैकप्रोपेगेशन। कैलकुलस के चेन रूल का उपयोग करते हुए, एल्गोरिथम लॉस से पीछे की ओर हर लेयर से गुज़रता है और हर एक वेट के लिए एक ग्रेडिएंट निकालता है — इस सवाल का जवाब "यदि मैं इस एक वेट को थोड़ा ऊपर धकेलूं, तो एरर बढ़ता है या घटता है, और कितना?"। यह वह तरकीब है जिसने AI विंटर को पिघलाया। 1980 के दशक में मशहूर हुई बैकप्रॉप ने लाखों वेट्स में अनुमान लगाने के बजाय कुशलता से दोष सौंपना संभव बनाया।

चौथा चरण है ग्रेडिएंट डिसेंट: हर वेट को उस दिशा में एक छोटा कदम धकेलें जो लॉस को कम करे, इस नियम का उपयोग करते हुए w = w − α × ∂L/∂w। एक धुंधली पहाड़ी पर खड़े होकर घाटी की तली तक पहुंचने की कोशिश करने की कल्पना करें; आप तली नहीं देख सकते, पर आप अपने पैरों के नीचे महसूस कर सकते हैं कि नीचे की ओर कौन सी दिशा है, तो आप उस दिशा में एक कदम लेते हैं और दोहराते हैं। लर्निंग रेट α आपकी कदम की लंबाई है, और यह शायद पूरे सिस्टम में सबसे अहम डायल है। बहुत बड़ी हो तो आप घाटी को पार कर जाते हैं और हमेशा के लिए इधर-उधर उछलते रहते हैं; बहुत छोटी हो तो आप हमेशा के लिए धीरे-धीरे बढ़ते हैं या रास्ते में किसी खाई में फंस जाते हैं।

दो सुधार जो आपको तुरंत मिलेंगे। मिनी-बैच: हर एक उदाहरण के बाद अपडेट करने (शोरगुल भरा) या केवल पूरे डेटासेट के बाद (धीमा) के बजाय, आप एक छोटे बैच के बाद अपडेट करते हैं — आमतौर पर 32 से 256 उदाहरण — जो स्थिर, GPU-फ्रेंडली, और व्यवहार में सही जगह है। और Adam: एक ज़्यादा स्मार्ट ऑप्टिमाइज़र जो हर वेट को अपनी एडैप्टिव कदम की लंबाई देता है और शोरगुल भरे ग्रेडिएंट को स्मूथ करने के लिए मोमेंटम जोड़ता है। Adam लगभग किसी भी प्रोजेक्ट पर शुरू करने के लिए एक व्यावहारिक डिफॉल्ट है — हालांकि फाइनेंस में, इसके कम सिग्नल-टू-नॉइज़ रेशियो के साथ, आपको फिर भी लर्निंग रेट, वेट डिके, और रुकने का बिंदु हाथ से ट्यून करना होगा।

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

Dropout सबसे लोकप्रिय है। हर ट्रेनिंग स्टेप के दौरान, हर न्यूरॉन की एक संभावना p (अक्सर 0.2–0.5) होती है अस्थायी रूप से बंद होने की। रैंडम टीममेट के गायब होते रहने पर भी काम करने के लिए मजबूर, नेटवर्क कुछ कमज़ोर न्यूरॉन्स पर सब कुछ दांव लगाने के बजाय अपने ज्ञान को कई न्यूरॉन्स में फैलाना सीखता है — एक ही मॉडल में बुना गया एक एंसेम्बल इफेक्ट। प्रेडिक्शन के समय सभी न्यूरॉन्स फिर से वापस चालू हो जाते हैं, उचित रूप से स्केल किए गए।

L1 और L2 पेनाल्टी बड़े वेट्स पर लॉस में एक टैक्स जोड़ते हैं। L2 (वेट डिके) किसी भी एक वेट को बहुत बड़ा होने से रोकता है, प्रभाव को समान रूप से फैलाता है। L1 ज़्यादा तीखा है: यह बेकार वेट्स को बिल्कुल शून्य तक पूरी तरह धकेलता है, ऑटोमैटिक फीचर सिलेक्शन करते हुए। एक फाइनेंशियल डेटासेट में जहां आपके सौ फीचर में से अधिकतर नॉइज़ हैं, L1 चुपचाप उन कुछ फीचर खोज सकता है जो वाकई सिग्नल रखते हैं।

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

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

Convolutional Neural Networks (CNN) इमेज के लिए बनाए गए थे। हर पिक्सल को हर न्यूरॉन से जोड़ने के बजाय, एक CNN इनपुट पर छोटे फिल्टर सरकाता है, लोकल पैटर्न की तलाश में — यहां एक एज, वहां एक टेक्सचर — और उसी फिल्टर को सब जगह फिर से इस्तेमाल करता है। शुरुआती लेयर एज पकड़ती हैं; गहरी लेयर उन्हें शेप और ऑब्जेक्ट में जोड़ती हैं। फाइनेंस में, शोधकर्ताओं ने CNN को इन पर पॉइंट किया है:

• कैंडलस्टिक चार्ट इमेज — चार्ट पढ़ने को एक विज़ुअल पैटर्न-रिकग्निशन काम के रूप में फिर से परिभाषित करना।
• ऑर्डर-बुक हीटमैप — डेप्थ-ऑफ-मार्केट स्नैपशॉट में सप्लाई/डिमांड इम्बैलेंस पहचानना।
• कच्चे प्राइस सीक्वेंस पर 1D कन्वोल्यूशन — छोटे टेम्पोरल मोटिफ सीखना जैसे एक इमेज CNN स्पेशियल मोटिफ सीखता है।

Recurrent Neural Networks (RNN) सीक्वेंस के लिए बनाए गए हैं। वे एक समय में एक टाइम स्टेप प्रोसेस करते हैं, हर स्टेप से अगले तक एक हिडन स्टेट — एक चलती हुई मेमोरी — ढोते हुए। सिद्धांत में यह उन्हें टाइम सीरीज़ के लिए आदर्श बनाता है। व्यवहार में, सादे RNN लंबे सीक्वेंस पर वैनिशिंग ग्रेडिएंट समस्या से अपंग हो जाते हैं: कई स्टेप पहले का सिग्नल वापस जाने के रास्ते में शून्य की तरफ सिकुड़ जाता है, तो नेटवर्क बस दूर का अतीत भूल जाता है।

Long Short-Term Memory (LSTM) नेटवर्क इसे कुछ सीखने योग्य गेट्स से ठीक करते हैं — फॉरगेट, इनपुट, और आउटपुट — जो हर स्टेप पर तय करते हैं कि मेमोरी से क्या मिटाना है, क्या लिखना है, और क्या पढ़ना है। यह गेटिंग एक LSTM को सैंकड़ों स्टेप में मायने वाली जानकारी थामे रखने देती है, और यही वजह है कि यह फाइनेंशियल टाइम सीरीज़ मॉडलिंग का वर्कहॉर्स बन गई, जहां कल की एक घटना अभी भी आज की प्राइस को हिलाती है।

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

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

न्यूरल नेटवर्क शानदार पैटर्न खोजने वाले हैं। पर ईमानदार शिक्षा का मतलब है यह बताना कि वे कहां टूटते हैं — और ट्रेडिंग में, वे महंगे तरीकों से टूटते हैं।

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

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

GPU स्टैंडर्ड हैं। उनके हज़ारों कोर एक ही ऑपरेशन को अलग-अलग डेटा पर एक साथ चलाते हैं, जो ठीक न्यूरल नेटवर्क गणित का आकार है। जो मॉडल CPU पर 8 घंटे रेंगता है वह एक आधुनिक GPU पर 15 मिनट में खत्म हो सकता है। NVIDIA का दबदबा है: कंज्यूमर कार्ड (एक RTX-क्लास GPU) सीखने के लिए ठीक हैं, जबकि डेटा-सेंटर कार्ड (A100, H100) और क्लाउड इंस्टेंस प्रोडक्शन-स्केल ट्रेनिंग संभालते हैं। TPU, Google के टेंसर गणित के लिए कस्टम चिप, Google Cloud के ज़रिए बहुत बड़े मॉडल पर चमकते हैं, पर व्यापक सॉफ्टवेयर सपोर्ट की वजह से GPU अधिकतर प्रैक्टिशनर्स के लिए व्यावहारिक डिफॉल्ट बने रहते हैं।

शुरू करने के लिए आपको कुछ खरीदने की ज़रूरत नहीं। Google Colab मुफ्त GPU टाइम देता है जो सीखने और प्रोटोटाइपिंग के लिए काफी है; अपने मॉडल बढ़ने के साथ मांग पर क्लाउड GPU किराए पर लें; डेडिकेटेड हार्डवेयर तभी खरीदें जब आप रोज़ ट्रेन कर रहे हों और क्लाउड बिल इसे सही ठहराए।

यहां से एक समझदार सीखने का रास्ता:

• कुछ इंजीनियर किए गए फीचर्स पर एक सादे फीडफॉरवर्ड नेटवर्क से शुरू करें — तेज़ ट्रेन करना, डिबग करना आसान, और एक ईमानदार बेसलाइन।
• कच्चे प्राइस सीक्वेंस पर एक 1D CNN आज़माएं और इसे उस बेसलाइन के सीधे मुकाबले में परखें।
• GaiaEx के API से कैंडलस्टिक डेटा के सीक्वेंस लेने वाला एक LSTM बनाएं।
• अटेंशन और ट्रांसफॉर्मर पढ़ें — सीक्वेंस के लिए तेज़ी से पसंदीदा आर्किटेक्चर बन रहे हैं।
• सबसे ऊपर, हमेशा अपने डीप मॉडल को XGBoost जैसे ग्रेडिएंट-बूस्टिंग बेसलाइन के सामने खड़ा करें। यदि न्यूरल नेटवर्क आपके टेबुलर फाइनेंशियल डेटा पर आउट-ऑफ-सैंपल सरल मॉडल को नहीं हरा सकता, तो सरल मॉडल को शिप करें और आगे बढ़ें।

वही लूप जिसने मूव 37 खोजा — प्रेडिक्ट करो, एरर मापो, वेट्स को धक्का दो, दोहराओ — वही लूप इस लिस्ट में हर सिस्टम के भीतर चल रहा है। उस लूप को समझें और आप डीप लर्निंग समझ जाते हैं; बाकी सब इसके ऊपर आर्किटेक्चर और इंजीनियरिंग है।