पिछले पाठों में आपने देखा कि न्यूरल नेटवर्क में वेट्स होते हैं, और ट्रेनिंग उन वेट्स को एडजस्ट करती है। लेकिन नेटवर्क को कैसे पता चलता है कि कौन से वेट्स बदलने हैं, और कितना? इसका जवाब है बैकप्रोपेगेशन - मॉडर्न डीप लर्निंग का सबसे महत्वपूर्ण एल्गोरिदम।
Andrej Karpathy इसे "न्यूरल नेटवर्क के बारे में समझने की सबसे ज़रूरी चीज़" कहते हैं। आइए देखें क्यों।
फॉरवर्ड पास के दौरान, डेटा नेटवर्क में बाएँ से दाएँ प्रवाहित होता है:
फिर प्रेडिक्शन की तुलना सही उत्तर से लॉस फंक्शन (अगले पाठ में) का उपयोग करके की जाती है। लॉस एक संख्या है जो कहती है: "आप इतने गलत हैं।"
कल्पना करें कि आपने एक केक बनाया और उसका स्वाद खराब निकला। आपने पाँच सामग्रियाँ इस्तेमाल कीं। सवाल यह है: कौन सी सामग्री ने खराब स्वाद में सबसे ज़्यादा योगदान दिया, और कितना?
बैकप्रोपेगेशन न्यूरल नेटवर्क के लिए बिल्कुल यही सवाल का जवाब देता है। यह हर एक वेट को दोष देता है, यह पूछकर: "अगर मैं इस वेट को थोड़ा सा बदलूँ, तो लॉस कितना बदलेगा?"
परिवर्तन की उस दर को ग्रेडिएंट कहते हैं, और यह कैलकुलस से आता है - विशेष रूप से, डेरिवेटिव से।
Geoffrey Hinton, जो "AI के गॉडफादर्स" में से एक हैं, ने कहा है कि बैकप्रोपेगेशन वह मुख्य विचार है जिसने डीप लर्निंग को व्यावहारिक बनाया। इसके बिना, लाखों पैरामीटर्स वाले नेटवर्क को ट्रेन करना कम्प्यूटेशनल रूप से असंभव होता।
न्यूरल नेटवर्क सरल ऑपरेशनों की श्रृंखलाएँ हैं जो एक साथ जुड़ी होती हैं। कैलकुलस का चेन रूल हमें बताता है कि संयोजित फंक्शनों का डिफरेंशिएशन कैसे करें:
अगर
y = f(g(x))है, तोdy/dx = f'(g(x)) × g'(x)।
Sign in to join the discussion
रोज़मर्रा का उदाहरण: आप एक दुकान तक ड्राइव करते हैं। आपकी गति इस पर निर्भर करती है कि आप एक्सेलरेटर कितना दबाते हैं। एक्सेलरेटर की स्थिति ट्रैफिक पर निर्भर करती है। यह जानने के लिए कि ट्रैफिक आपकी गति को कैसे प्रभावित करता है, आप गुणा करते हैं: (गति प्रति एक्सेलरेटर प्रेस) × (एक्सेलरेटर प्रेस प्रति ट्रैफिक स्थिति)। यही चेन रूल है - एक श्रृंखला के साथ स्थानीय परिवर्तन दरों को गुणा करना।
बैकप्रोपेगेशन को Rumelhart, Hinton और Williams के 1986 के एक ऐतिहासिक पेपर में लोकप्रिय बनाया गया था, लेकिन रिवर्स-मोड ऑटोमैटिक डिफरेंशिएशन का मूल विचार 1960 के दशक से है।
PyTorch जैसे आधुनिक फ्रेमवर्क फॉरवर्ड पास के दौरान एक कम्प्यूटेशन ग्राफ बनाते हैं। हर ऑपरेशन - जोड़, गुणा, ReLU - एक नोड बन जाता है। बैकप्रोपेगेशन फिर इस ग्राफ को उल्टा चलता है, हर नोड पर चेन रूल लगाकर ग्रेडिएंट्स की गणना करता है।
इसे एक नदी प्रणाली की तरह सोचें। लॉस अंत में समुद्र है। बैकप्रोप हर सहायक नदी को ऊपर की ओर ट्रेस करता है यह पता लगाने के लिए कि हर स्रोत (वेट) ने अंतिम प्रवाह में कितना योगदान दिया।
मान लीजिए L = (w × x - y)² जहाँ w = 2, x = 3, y = 10।
w × x = 6, फिर 6 - 10 = -4, फिर (-4)² = 16। लॉस = 16।dL/d(diff) = 2 × (-4) = -8, फिर d(diff)/d(wx) = 1, तो dL/d(wx) = -8।d(wx)/dw = x = 3, तो dL/dw = -8 × 3 = -24।−24 का ग्रेडिएंट हमें बताता है: w बढ़ाने से लॉस तेज़ी से कम होगा। यही वह सिग्नल है जो हमें सुधार के लिए चाहिए।
चेन रूल में, हम हर नोड पर स्थानीय डेरिवेटिव्स के साथ क्या करते हैं?
एक गहरे नेटवर्क में, ग्रेडिएंट्स को कई लेयर्स से गुज़रना पड़ता है। हर लेयर ग्रेडिएंट को अपने स्थानीय डेरिवेटिव से गुणा करती है। इससे दो खतरनाक विफलता मोड बनते हैं:
अगर स्थानीय डेरिवेटिव्स छोटे हैं (जैसे, सिगमॉइड फंक्शन 0 या 1 के पास संतृप्त होता है), तो बार-बार गुणा करने से ग्रेडिएंट्स शून्य की ओर सिकुड़ जाते हैं। शुरुआती लेयर्स मुश्किल से सीख पाती हैं - उन्हें लगभग कोई सिग्नल नहीं मिलता। इस समस्या ने शुरुआती डीप नेटवर्क को परेशान किया।
अगर स्थानीय डेरिवेटिव्स बड़े हैं, तो ग्रेडिएंट्स तेज़ी से बढ़ते हैं। वेट्स को भारी अपडेट मिलते हैं और नेटवर्क अस्थिर हो जाता है, NaN वैल्यूज़ पैदा करता है।
ReLU का डेरिवेटिव या तो 0 है या 1 - जब सक्रिय होता है तो यह कभी ग्रेडिएंट को नहीं सिकोड़ता। यह सरल गुण डीप नेटवर्क की ट्रेनिंग के लिए क्रांतिकारी क्यों रहा होगा?
आधुनिक समाधानों में शामिल हैं:
एक बार बैकप्रोप हर ग्रेडिएंट की गणना कर लेता है, ऑप्टिमाइज़र (अगले पाठ में) हर वेट को अपडेट करता है:
w_new = w_old - learning_rate × gradient
लर्निंग रेट स्टेप साइज़ को नियंत्रित करता है। बहुत बड़ा होने पर आप ओवरशूट कर जाते हैं; बहुत छोटा होने पर ट्रेनिंग हमेशा के लिए चलती रहती है। ग्रेडिएंट आपको दिशा बताता है; लर्निंग रेट बताता है कि कितना आगे जाना है।
डीप नेटवर्क में वैनिशिंग ग्रेडिएंट्स का कारण क्या है?
हर बार जब ChatGPT अपनी नेक्स्ट-वर्ड प्रेडिक्शन में सुधार करता है, हर बार जब एक सेल्फ-ड्राइविंग कार अपनी स्टीयरिंग को बेहतर करती है, बैकप्रोपेगेशन नीचे चल रहा होता है। यह वह एल्गोरिदम है जो गलतियों से सीखना गणितीय रूप से सटीक बनाता है।
बैकप्रोप के बिना, लाखों - या अरबों - पैरामीटर्स वाले नेटवर्क को ट्रेन करने का कोई कुशल तरीका नहीं होता।
एक ग्रेडिएंट हमें एक वेट के बारे में क्या बताता है?
Karpathy ज़ोर देते हैं कि बैकप्रोप "बस चेन रूल का पुनरावर्ती अनुप्रयोग है।" अगर आप चेन रूल और कम्प्यूटेशन ग्राफ समझते हैं, तो आप बैकप्रोप समझते हैं। और कौन सी जटिल प्रणालियाँ सरल, संयोज्य टुकड़ों में तोड़कर समझी जा सकती हैं?