दिमाग़ की कोशिका से कृत्रिम न्यूरॉन तक
हमारे दिमाग़ में अरबों तंत्रिका कोशिकाएँ हैं। हर कोशिका संकेत लेती है, और कुल संकेत काफ़ी तेज़ हो तो आगे संकेत भेजती है। कंप्यूटर वैज्ञानिकों ने यह विचार लेकर कृत्रिम न्यूरॉन बनाया।
- इनपुट (x): अंदर आने वाली संख्याएँ, जैसे पिक्सेल की चमक।
- भार (w): कौन-सा इनपुट कितना ज़रूरी है। बड़ा भार = ज़्यादा ध्यान। ऋणात्मक भार = यह इनपुट उलटा असर डालता है।
- बायस (b): एक अतिरिक्त संख्या जो तय करती है कि फायर करना कितना आसान है।
- भारित योग: z = w₁x₁ + w₂x₂ + … + b
- सक्रियण फलन: z को आउटपुट में बदलता है।
पहला ऐसा मॉडल परसेप्ट्रॉन (1958) था: z ≥ 0 तो 1, नहीं तो 0।
सक्रियण फलन: न्यूरॉन कब फायर करता है?
सक्रियण फलन के बिना नेटवर्क सिर्फ़ सीधी रेखा वाले नियम सीख पाता। सक्रियण एक मोड़ जोड़ता है, जिससे जटिल पैटर्न सीखे जा सकते हैं।
- स्टेप: 0 या 1।
- सिग्मॉइड: हर संख्या को 0 से 1 के बीच दबा देता है। σ(z) = 1 ÷ (1 + e−z), σ(0) = 0.5।
- ReLU: z धनात्मक हो तो z, वरना 0। गहरे नेटवर्क में सबसे लोकप्रिय।
- सॉफ़्टमैक्स: आउटपुट परत में अंकों को प्रायिकता (probability) में बदलता है, जिनका योग 1 होता है।
परतें: इनपुट, छिपी और आउटपुट
इनपुट परत सिर्फ़ डेटा रखती है (28 × 28 चित्र के लिए 784 संख्याएँ)। छिपी परतें पैटर्न ढूँढती हैं: पहली परतें किनारे पहचानती हैं, बाद की परतें उन्हें जोड़कर आकार बनाती हैं। आउटपुट परत उत्तर देती है, जैसे अंक 0–9 के लिए 10 न्यूरॉन।
अगर एक परत का हर न्यूरॉन अगली परत के हर न्यूरॉन से जुड़ा हो तो उसे पूर्ण रूप से जुड़ी (fully connected) परत कहते हैं। 3 और 4 न्यूरॉन वाली परतों के बीच 3 × 4 = 12 भार और 4 बायस होते हैं।
नेटवर्क कैसे सीखता है: loss, बैकप्रोपेगेशन और ग्रेडिएंट डिसेंट
- फ़ॉरवर्ड पास: उदाहरण डालो, संख्याएँ आउटपुट तक जाती हैं।
- Loss (गलती): आउटपुट को सही उत्तर से मिलाओ। गलत अंदाज़े पर loss बड़ा होता है।
- बैकप्रोपेगेशन: आउटपुट से पीछे चलकर पता करो कि किस भार ने कितनी गलती करवाई।
- ग्रेडिएंट डिसेंट: हर भार को उस दिशा में छोटा कदम बदलो जिससे loss घटे। कदम का आकार = लर्निंग रेट।
- यह सब बार-बार करो। पूरे डेटा पर एक चक्कर = एक एपॉक (epoch)।
कम डेटा पर बहुत ज़्यादा प्रशिक्षण से ओवरफ़िटिंग होती है: नेटवर्क रट लेता है और नए डेटा पर गलत करता है। इसलिए अलग टेस्ट सेट रखते हैं।
डीप लर्निंग: CNN, RNN और फ़्रेमवर्क
डीप लर्निंग = बहुत सारी छिपी परतों वाले नेटवर्क, बड़े डेटा और तेज़ चिप (GPU) पर प्रशिक्षित।
- CNN (कन्वोल्यूशनल न्यूरल नेटवर्क): भारों का छोटा ग्रिड, जिसे फ़िल्टर कहते हैं, चित्र पर खिसकता है। हर जगह गुणा-जोड़ करके फ़ीचर मैप बनता है जो किनारे या आकार वाली जगह पर चमकता है। चेहरा पहचान, मेडिकल स्कैन, स्वचालित कार में।
- RNN (रिकरंट न्यूरल नेटवर्क): इसमें लूप होता है, पिछले शब्द का आउटपुट अगले शब्द के साथ फिर अंदर जाता है – छोटी याददाश्त। वाक्य, आवाज़, संगीत के लिए। नए ट्रांसफ़ॉर्मर मॉडल लूप की जगह attention इस्तेमाल करते हैं और आज के चैटबॉट व अनुवादक चलाते हैं।
- फ़्रेमवर्क: तैयार कोड लाइब्रेरी जैसे TensorFlow, Keras, PyTorch। तुम परतें बताओ, गणित और बैकप्रोपेगेशन फ़्रेमवर्क करता है।
करके देखो: काग़ज़-पेंसिल से न्यूरॉन बनो
फ़ैसला: बाहर खेलने जाएँ या नहीं? x₁ = 1 अगर धूप है, x₂ = 1 अगर होमवर्क पूरा है। भार w₁ = 2, w₂ = 3, बायस b = −4। नियम: z ≥ 0 तो बाहर जाओ।
- धूप है, होमवर्क नहीं: z = 2 + 0 − 4 = −2 → घर पर रहो।
- धूप है, होमवर्क पूरा: z = 2 + 3 − 4 = 1 → खेलने जाओ!
अब बायस −1 करके फिर जाँचो। फिर ऊपर 3D के फ़्री-प्ले में स्लाइडर से यही करो।
मुख्य सूत्र और परिभाषाएँ
- भारित योग: z = w₁x₁ + w₂x₂ + … + wₙxₙ + b
- आउटपुट: a = f(z), f = सक्रियण फलन
- सिग्मॉइड: σ(z) = 1 ÷ (1 + e^(−z)); ReLU: f(z) = max(0, z)
- m और n न्यूरॉन वाली परतों के बीच भार = m × n (+ n बायस)
- ग्रेडिएंट डिसेंट: नया w = पुराना w − लर्निंग रेट × (w के लिए loss का ढाल)
हल किए गए उदाहरण
1. इनपुट x₁ = 2, x₂ = 1, भार w₁ = 0.5, w₂ = −1, बायस b = 0.5। z और ReLU आउटपुट निकालो।
z = 0.5×2 + (−1)×1 + 0.5 = 1 − 1 + 0.5 = 0.5। ReLU(0.5) = 0.5।
2. स्टेप न्यूरॉन z ≥ 0 पर फायर करता है। इनपुट (1, 1), भार (1, 1), बायस −1.5। क्या यह फायर करेगा? यह न्यूरॉन क्या करता है?
z = 1 + 1 − 1.5 = 0.5 ≥ 0 → फायर। (1,0) या (0,1) पर z = −0.5 → नहीं; (0,0) पर z = −1.5 → नहीं। यह तभी फायर करता है जब दोनों इनपुट 1 हों: यह AND गेट जैसा है।
3. पूर्ण रूप से जुड़े नेटवर्क 4 → 5 → 3 में कितने भार और बायस हैं?
भार: 4×5 + 5×3 = 20 + 15 = 35। बायस: हर गैर-इनपुट न्यूरॉन का एक = 5 + 3 = 8। कुल पैरामीटर = 43।
4. एक भार 0.8 है। इस भार के लिए loss का ढाल 2 है और लर्निंग रेट 0.1। नया भार निकालो।
नया w = 0.8 − 0.1 × 2 = 0.6। भार घटा, क्योंकि उसे बढ़ाने से loss बढ़ता।
5. 3×3 फ़िल्टर 6×6 चित्र पर एक-एक कदम खिसकता है (पैडिंग नहीं)। फ़ीचर मैप का आकार?
हर दिशा में स्थान = 6 − 3 + 1 = 4। फ़ीचर मैप = 4 × 4 (3D के चरण 5 जैसा)।
6. z = 0 पर और z बहुत बड़ा होने पर सिग्मॉइड आउटपुट क्या है?
σ(0) = 1 ÷ (1 + 1) = 0.5। z बहुत बड़ा हो तो e^(−z) ≈ 0, इसलिए σ ≈ 1। सिग्मॉइड हमेशा 0 और 1 के बीच रहता है।
आम गलतियाँ
- कृत्रिम न्यूरॉन को असली दिमाग़ी कोशिका समझना। यह सिर्फ़ दिमाग़ से प्रेरित एक गणितीय विचार है।
- z निकालते समय बायस जोड़ना भूल जाना।
- इनपुट परत को भार वाली न्यूरॉन परत गिनना। वह सिर्फ़ डेटा रखती है।
- मानना कि ज़्यादा प्रशिक्षण हमेशा बेहतर है। कम डेटा पर ज़्यादा प्रशिक्षण से ओवरफ़िटिंग होती है।