Neural Network Learning Step-by-Step

Neural Network Learning Step-by-Step

आइए समझते हैं कि एक न्यूरल नेटवर्क की बुनियादी बनावट कैसी होती है। जैसे हमारे दिमाग में न्यूरॉन्स का जाल होता है, वैसे ही कंप्यूटर में हम कृत्रिम न्यूरॉन्स को अलग-अलग लेयर्स यानी परतों में सजाते हैं। सबसे पहले आती है हमारी इनपुट लेयर, जो बाहरी डेटा को स्वीकार करती है।

इनपुट लेयर के बाद आती है हिडन लेयर, जिसे हम छिपी हुई परत भी कहते हैं। यही वो जगह है जहाँ असली गणना और पैटर्न की पहचान होती है। और अंत में, हमें मिलता है आउटपुट लेयर पर अंतिम परिणाम।

अब, ये न्यूरॉन्स आपस में जुड़े होते हैं। इन कनेक्शनों को हम वेट्स यानी भार कहते हैं। हर कनेक्शन का अपना एक वेट होता है, जो यह तय करता है कि कौन सा इनपुट सिग्नल कितना मजबूत या महत्वपूर्ण है।

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

इस एरर को हम गणितीय रूप से वाई माइनस वाई-हैट लिखते हैं। यहाँ हमारी एरर शून्य दशमलव तीन है। लेकिन अगर नेटवर्क शून्य के बजाय एक दशमलव तीन प्रेडिक्ट करता, तो एरर ऋणात्मक यानी नेगेटिव हो जाती। सभी गलतियों को सही ढंग से जोड़ने के लिए और बड़ी गलतियों को अधिक सजा देने के लिए, हम इसका स्क्वायर यानी वर्ग कर देते हैं। इसे हम स्क्वायर्ड एरर कहते हैं, जो इस अंतर का वर्ग होती है।

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

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

गणितीय रूप से, हम हर भार को उसके पुराने मान में से ढलान और लर्निंग रेट के गुणनफल को घटाकर अपडेट करते हैं। लर्निंग रेट यह तय करता है कि हमारे कदम कितने बड़े होंगे। इस तरह, धीरे-धीरे नेटवर्क सही उत्तर की ओर बढ़ने लगता है।

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

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

इस बिंदु पर आकर, हमारा लॉस न्यूनतम स्तर पर पहुँच जाता है। अब अगर हम नेटवर्क को कोई नया इनपुट देंगे, तो यह बिना किसी हिचकिचाहट के बिल्कुल सही और सटीक उत्तर देगा। बधाई हो! आपका न्यूरल नेटवर्क अब पूरी तरह से प्रशिक्षित हो चुका है।