न्यूरल नेटवर्क समझाए गए

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

इनपुट, दो हिडन लेयर और एक आउटपुट वाला एक छोटा न्यूरल नेटवर्क, जिसके कनेक्शन नीले और नारंगी हैं, और उसके बगल में एक तल जहाँ एक घुमावदार सीमा नीले और नारंगी बिंदुओं को अलग करती है
इनपुट, दो हिडन लेयर और एक आउटपुट वाला एक छोटा न्यूरल नेटवर्क, जिसके कनेक्शन नीले और नारंगी हैं, और उसके बगल में एक तल जहाँ एक घुमावदार सीमा नीले और नारंगी बिंदुओं को अलग करती है

एक न्यूरॉन

एक कृत्रिम न्यूरॉन कुछ संख्याएँ लेता है, हर एक को एक वेट से गुणा करता है, उन्हें एक बायस के साथ जोड़ता है और कुल योग को एक एक्टिवेशन फ़ंक्शन से गुज़ारता है। वॉरेन मैककलॉक और वॉल्टर पिट्स ने 1943 में ऐसी इकाई का वर्णन किया, और 1958 में फ़्रैंक रोज़ेनब्लैट ने परसेप्ट्रॉन बनाया, एक ऐसी मशीन जो उदाहरणों से अपने वेट ख़ुद सीखती थी। दो इनपुट x और y के साथ वेट वाला योग एक सीधी रेखा पर शून्य होता है, इसलिए एक अकेला न्यूरॉन तल को दो हिस्सों में बाँटता है: एक तरफ़ उसकी हाँ, दूसरी तरफ़ उसकी ना, और अगर एक्टिवेशन चिकना हो तो बीच में नरम बदलाव।

वॉरेन मैककलो (बाएँ, दाढ़ी वाले) और सहयोगी
वॉरेन मैककलो (बाएँ, दाढ़ी वाले) और सहयोगी

एक्टिवेशन फ़ंक्शन

एक्टिवेशन फ़ंक्शन ही नेटवर्क को एक साधारण योग से बढ़कर बनाता है। सिग्मॉइड किसी भी संख्या को 0 से 1 के बीच दबा देता है और tanh उसे −1 से 1 के बीच; दोनों चिकने S-आकार के वक्र हैं। ReLU, यानी रेक्टिफ़ाइड लीनियर यूनिट, ऋणात्मक संख्याओं के लिए शून्य और बाकी के लिए स्वयं वह संख्या देता है; लगभग 2010 से यह डीप नेटवर्क के लिए आम पसंद है क्योंकि यह सस्ता है और ग्रेडिएंट को फीका पड़ने से रोकता है। इस तरह के मोड़ के बिना लेयरों को एक के ऊपर एक रखना बेकार होता: रैखिक फ़ंक्शनों की शृंखला फिर भी एक ही रैखिक फ़ंक्शन है, और उसकी सीमा फिर भी एक सीधी रेखा है।

लेयर

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

त्रुटि मापना

सीखने के लिए नेटवर्क को एक ऐसी संख्या चाहिए जो बताए कि वह कितना ग़लत है: लॉस। दो वर्गों के लिए आम पसंद क्रॉस-एन्ट्रॉपी है। अगर नेटवर्क किसी नीले बिंदु को नीला होने की प्रायिकता p देता है, तो उस बिंदु की लागत −log p है, जो p के 1 के पास होने पर छोटी होती है और p के 0 की ओर जाने पर असीमित रूप से बढ़ती है। लॉस सभी बिंदुओं पर औसत लागत है। जो नेटवर्क हर जगह आधा अनुमान लगाता है, उसका लॉस log 2, लगभग 0.693 होता है, जो सैंडबॉक्स के चार्ट के शुरुआती बिंदु के क़रीब है।

ग्रेडिएंट डिसेंट और बैकप्रोपेगेशन

लॉस को सभी वेट के ऊपर फैले एक भू-दृश्य की तरह सोचें। ग्रेडिएंट डिसेंट ढलान की ओर नीचे जाने वाली दिशा, यानी ऋणात्मक ग्रेडिएंट, खोजता है और उस ओर एक छोटा कदम बढ़ाता है, बार-बार। हज़ारों वेट के लिए ग्रेडिएंट निकालना महँगा लगता है, लेकिन बैकप्रोपेगेशन यह पीछे की ओर के एक ही चक्कर (बैकवर्ड पास) में कर देता है: आउटपुट पर त्रुटि से शुरू करके चेन रूल हर लेयर को दोष में उसका हिस्सा सौंपता है, लेयर-दर-लेयर पीछे इनपुट तक। इस विधि का वर्णन कई बार हुआ, और डेविड रूमेलहार्ट, जेफ़्री हिंटन और रोनाल्ड विलियम्स के 1986 के शोधपत्र ने इसे नेटवर्क ट्रेन करने का मानक तरीक़ा बना दिया। हर कदम के लिए सभी बिंदुओं के बजाय बिंदुओं का एक छोटा यादृच्छिक बैच इस्तेमाल करना, यानी स्टोकैस्टिक ग्रेडिएंट डिसेंट, ज़्यादा तेज़ है और उतना ही अच्छा काम करता है।

जेफ्री हिंटन, आधुनिक न्यूरल नेटवर्क के संस्थापकों में से एक
जेफ्री हिंटन, आधुनिक न्यूरल नेटवर्क के संस्थापकों में से एक

लर्निंग रेट

कदम के आकार को लर्निंग रेट कहते हैं, और यही वह सेटिंग है जो अक्सर तय करती है कि ट्रेनिंग सफल होगी या नहीं। बहुत छोटी हो तो लॉस इतनी धीमी गति से नीचे सरकता है कि लगता है कुछ हो ही नहीं रहा। बहुत बड़ी हो तो हर कदम उस घाटी को पार कर जाता है जिसकी ओर वह जा रहा था: लॉस ऊपर-नीचे उछलता है, या बड़े नेटवर्क में तब तक फूटता है जब तक संख्याएँ ओवरफ़्लो न हो जाएँ। ReLU के साथ एक बड़ा कदम न्यूरॉनों को ऐसी स्थिति में भी धकेल सकता है जहाँ हर बिंदु के लिए उनका योग ऋणात्मक हो; तब वे शून्य देते हैं, कोई ग्रेडिएंट नहीं पाते और कभी नहीं उबरते। सैंडबॉक्स में सर्पिल को 3 की रेट से आज़माएँ: tanh के साथ लॉस उछलता है, ReLU के साथ कई न्यूरॉन ख़ाली हो जाते हैं और लॉस 0.69 के आसपास अटक जाता है। फिर उसे रेंगते देखने के लिए 0.001 आज़माएँ।

ओवरफ़िटिंग

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

ख़ुद आज़माएँ

न्यूरल नेटवर्क सैंडबॉक्स खोलें और आठ-आठ न्यूरॉन की अधिकतम चार हिडन लेयर वाला नेटवर्क छह डेटासेट पर ट्रेन करें, जिनमें आपके ख़ुद क्लिक करके जोड़े गए बिंदु भी शामिल हैं। हर न्यूरॉन एक छोटे नक्शे के रूप में दिखता है कि वह किस पर प्रतिक्रिया देता है, और हर वेट एक नीले या नारंगी कनेक्शन के रूप में, ताकि आप नेटवर्क को अपनी ख़ुद की विशेषताएँ गढ़ते देख सकें। वृत्त को बिना हिडन लेयर के आज़माएँ, फिर इनपुट के रूप में x² और y² जोड़ें; सर्पिल को एक लेयर के साथ, फिर तीन के साथ आज़माएँ; और एक छोटे डेटासेट में शोर जोड़कर उसे ओवरफ़िट कराएँ।

अक्सर पूछे जाने वाले प्रश्न

क्या बड़े AI मॉडल भी इसी तरह काम करते हैं?

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

ट्रेनिंग यादृच्छिक वेट से क्यों शुरू होती है?

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

दो बार चलाने पर अलग-अलग सीमाएँ क्यों बनती हैं?

हर बार ट्रेनिंग अलग यादृच्छिक वेट से शुरू होती है और बिंदुओं को अलग यादृच्छिक क्रम में देखती है, और लॉस के भू-दृश्य में कई घाटियाँ हैं जो लगभग बराबर अच्छी हैं। दो नेटवर्क अलग आकार की सीमाओं के साथ ट्रेनिंग बिंदुओं को बराबर अच्छी तरह वर्गीकृत कर सकते हैं, और जिन क्षेत्रों में कोई डेटा नहीं है वहाँ वे असहमत हो सकते हैं।

क्या ज़्यादा लेयर हमेशा बेहतर होती हैं?

नहीं। गहरे नेटवर्क कम न्यूरॉनों से ज़्यादा जटिल आकृतियाँ दर्शा सकते हैं, लेकिन उन्हें ट्रेन करना कठिन होता है और छोटे डेटासेट पर वे ज़्यादा आसानी से ओवरफ़िट करते हैं। सैंडबॉक्स की समस्याओं के लिए आमतौर पर एक या दो हिडन लेयर काफ़ी होती हैं; सर्पिल ही वह समस्या है जिसे ज़्यादा लेयर से साफ़ फ़ायदा होता है।

आज़माने के लिए तैयार?

अपने ब्राउज़र में PictorX खोलें — शुरू करने के लिए इंस्टॉल या क्रेडिट कार्ड की ज़रूरत नहीं।

न्यूरल नेटवर्क सैंडबॉक्स खोलें