🧠
AI Sprouts • मध्यम⏱️ 35 मिनट पढ़ने का समय
न्यूरल नेटवर्क का परिचय — AI परतों में कैसे सोचता है
मस्तिष्क से प्रेरित एल्गोरिदम 👋
पिछले पाठ में आपने डिसीज़न ट्री, KNN और लीनियर रिग्रेशन सीखे। ये शक्तिशाली हैं — लेकिन चेहरा पहचानने या भाषा समझने जैसे जटिल कार्यों में संघर्ष करते हैं।
इसके लिए हमें न्यूरल नेटवर्क चाहिए — एल्गोरिदम जो आपके मस्तिष्क की कार्यप्रणाली से प्रेरित हैं।
न्यूरॉन से कृत्रिम न्यूरॉन तक 🔬
आपके मस्तिष्क में लगभग 86 अरब न्यूरॉन हैं। हर एक:
- अन्य न्यूरॉन से सिग्नल प्राप्त करता है
- उन सिग्नलों को प्रोसेस करता है (जोड़ता है)
- फ़ैसला करता है कि फायर करना है या नहीं
कृत्रिम न्यूरॉन भी ऐसा ही करता है, लेकिन संख्याओं के साथ:
- इनपुट के रूप में संख्याएं प्राप्त करता है
- हर इनपुट को एक वेट से गुणा करता है
- सब जोड़ देता है
- एक्टिवेशन फ़ंक्शन से फ़ैसला करता है
इनपुट वेट योग एक्टिवेशन आउटपुट
────── ──── ─── ────────── ──────
x₁ = 0.5 ──→ w₁ = 0.8 ─┐
├──→ 1.25 ──→ f(1.25) ──→ 0.78
x₂ = 0.3 ──→ w₂ = 1.5 ─┘
योग = (0.5 × 0.8) + (0.3 × 1.5) = 0.40 + 0.85 = 1.25
🤔
Think about it:
वेट को मिक्सिंग बोर्ड पर वॉल्यूम नॉब्स की तरह सोचें। हर इनपुट एक अलग वाद्ययंत्र है। वेट नियंत्रित करते हैं कि हर वाद्ययंत्र कितना तेज़ है। न्यूरॉन उन्हें मिलाता है, और एक्टिवेशन फ़ंक्शन फ़ैसला करता है कि संयुक्त ध्वनि आगे भेजने लायक है या नहीं।
परतें: न्यूरॉन कैसे संगठित होते हैं 🏗️
एक अकेला न्यूरॉन ज़्यादा कुछ नहीं कर सकता। शक्ति परतों में संगठित होने से आती है।
1. इनपुट लेयर — आँखें और कान 👀
- कच्चा डेटा प्राप्त करती है
- हर इनपुट फ़ीचर के लिए एक न्यूरॉन
2. हिडन लेयर — सोचने वाला दिमाग 🧠
- यहाँ असली सीखना होता है
- हर न्यूरॉन डेटा में एक पैटर्न खोजता है
- ज़्यादा हिडन लेयर = ज़्यादा जटिल पैटर्न
3. आउटपुट लेयर — जवाब 💡
- अंतिम प्रेडिक्शन देती है
- वर्गीकरण के लिए: हर श्रेणी का एक न्यूरॉन
- रिग्रेशन के लिए: एक संख्या वाला एक न्यूरॉन
इनपुट लेयर हिडन लेयर 1 हिडन लेयर 2 आउटपुट लेयर
(3 फ़ीचर) (4 न्यूरॉन) (4 न्यूरॉन) (2 क्लास)
[x₁] ──────→ [h₁] ──────→ [h₅] ──────→ [बिल्ली: 0.92]
[x₂] ──────→ [h₂] ──────→ [h₆] ──────→ [कुत्ता: 0.08]
[x₃] ──────→ [h₃] ──────→ [h₇]
[h₄] ──────→ [h₈]
🤯
"डीप लर्निंग" का मतलब बस एक न्यूरल नेटवर्क है जिसमें कई हिडन लेयर हों — 2 से ज़्यादा। GPT-4 में 100 से ज़्यादा लेयर हैं! ज़्यादा लेयर नेटवर्क को अधिक अमूर्त पैटर्न सीखने देती हैं: किनारे → आकार → वस्तुएं → दृश्य।
एक्टिवेशन फ़ंक्शन — निर्णयकर्ता 💧
न्यूरॉन अपने इनपुट जोड़ने के बाद फ़ैसला करता है: मुझे एक्टिवेट होना चाहिए या नहीं?
पानी के प्रवाह की उपमा 🚿
एक वाल्व वाली पानी की पाइप कल्पना करें:
- पानी अंदर आता है (इनपुट का भारित योग)
- वाल्व नियंत्रित करता है क्या बाहर जाता है (एक्टिवेशन फ़ंक्शन)
सामान्य एक्टिवेशन फ़ंक्शन
ReLU — सरल गेट
- पॉज़िटिव इनपुट → गुज़रने दो
- नेगेटिव इनपुट → रोक दो (आउटपुट शून्य)
def relu(x):
return max(0, x)
print(relu(3.5)) # 3.5 (पॉज़िटिव → गुज़रता है)
print(relu(-2.0)) # 0.0 (नेगेटिव → रुक गया)
Sigmoid — धीमा दबाव
- किसी भी इनपुट को 0 और 1 के बीच दबा देता है
- संभावनाओं के लिए सही: "0.87 संभावना है कि यह बिल्ली है"
import math
def sigmoid(x):
return 1 / (1 + math.exp(-x))
print(sigmoid(5.0)) # 0.993 (बहुत विश्वस्त "हाँ")
print(sigmoid(0.0)) # 0.500 (पूरी तरह अनिश्चित)
print(sigmoid(-5.0)) # 0.007 (बहुत विश्वस्त "नहीं")
Softmax — वोट गिनने वाला
- आउटपुट लेयर में वर्गीकरण के लिए उपयोग
- कई मानों को ऐसी संभावनाओं में बदलता है जो 1 तक जुड़ती हैं
कच्चे आउटपुट: [2.0, 1.0, 0.5]
Softmax के बाद: [0.59, 0.24, 0.17] → बिल्ली (59%), कुत्ता (24%), पक्षी (17%)
💡
एक्टिवेशन फ़ंक्शन क्यों ज़रूरी हैं? इनके बिना न्यूरल नेटवर्क — चाहे कितनी भी लेयर हों — बस लीनियर रिग्रेशन होगा। एक्टिवेशन फ़ंक्शन नॉन-लीनियरिटी लाते हैं, जिससे नेटवर्क वक्र और जटिल पैटर्न सीख सकता है।
फॉरवर्ड प्रोपेगेशन — डेटा का प्रवाह 🌊
रिले रेस की तरह सोचें:
- इनपुट लेयर डेटा प्राप्त करती है और पहली हिडन लेयर को भेजती है
- हर न्यूरॉन गुणा, जोड़ और एक्टिवेट करता है
- परिणाम अगली लेयर को जाते हैं
- यह आउटपुट लेयर तक जारी रहता है
- आउटपुट लेयर अंतिम प्रेडिक्शन देती है
एक ठोस उदाहरण
सेब या संतरा वर्गीकृत करें:
इनपुट: वज़न = 150g, रंग = 0.8 (नारंगी जैसा)
चरण 1 — इनपुट लेयर मान भेजती है:
x₁ = 150 (वज़न), x₂ = 0.8 (रंग)
चरण 2 — हिडन न्यूरॉन 1:
योग = (150 × 0.01) + (0.8 × 2.0) + bias(0.1) = 3.2
आउटपुट = ReLU(3.2) = 3.2
चरण 3 — हिडन न्यूरॉन 2:
योग = (150 × -0.005) + (0.8 × 1.5) + bias(0.3) = 0.75
आउटपुट = ReLU(0.75) = 0.75
चरण 4 — आउटपुट लेयर:
सेब_स्कोर = (3.2 × -0.5) + (0.75 × 0.8) = -1.0
संतरा_स्कोर = (3.2 × 0.7) + (0.75 × 0.3) = 2.465
चरण 5 — Softmax:
सेब: 18%
संतरा: 82% ← प्रेडिक्शन: संतरा! 🍊
बैकप्रोपेगेशन — गलतियों से सीखना 🔄
फॉरवर्ड प्रोपेगेशन प्रेडिक्शन देता है। लेकिन अगर गलत हो? तब बैकप्रोपेगेशन आता है।
डार्ट फेंकने की उपमा 🎯
- डार्ट फेंकें (फॉरवर्ड प्रोपेगेशन — प्रेडिक्शन बनाएं)
- कोई बताता है कितना दूर गए (एरर कैलकुलेट करें)
- निशाना सुधारें (वेट अपडेट करें)
- फिर से फेंकें — इस बार क़रीब!
- हज़ारों बार दोहराएं
फॉरवर्ड प्रोपेगेशन: डेटा → नेटवर्क → प्रेडिक्शन
↓
तुलना: प्रेडिक्शन vs असली जवाब = एरर
↓
बैकप्रोपेगेशन: एरर नेटवर्क में पीछे जाता है
↓
अपडेट: वेट सुधारें ताकि एरर कम हो
↓
दोहराएं: हज़ारों बार!
🤔
Think about it:
एक फैक्ट्री की असेंबली लाइन कल्पना करें जो खराब उत्पाद बना रही है। समस्या ठीक करने के लिए आप अंतिम उत्पाद से पीछे हर स्टेशन तक जाते हैं: "क्या पैकेजिंग गलत थी? पेंटिंग? कच्चा माल?" हर स्टेशन अपनी प्रक्रिया सुधारता है। यही बैकप्रोपेगेशन है।
इंटरैक्टिव: नेटवर्क में डेटा ट्रेस करें 🔍
स्पैम ई-मेल वर्गीकृत करने वाले छोटे नेटवर्क में डेटा ट्रेस करें।
फ़ीचर:
- x₁ = विस्मयादिबोधक चिह्नों की संख्या (5)
- x₂ = "मुफ़्त" शब्द है (1 = हाँ)
import math
# इनपुट
x1, x2 = 5, 1
# हिडन न्यूरॉन 1
z1 = (x1 * 0.6) + (x2 * 0.9) + 0.1 # = 4.0
h1 = max(0, z1) # ReLU → 4.0
# हिडन न्यूरॉन 2
z2 = (x1 * 0.3) + (x2 * 0.4) + 0.2 # = 2.1
h2 = max(0, z2) # ReLU → 2.1
# आउटपुट न्यूरॉन
z_out = (h1 * 0.7) + (h2 * 0.5) - 0.5 # = 3.35
output = 1 / (1 + math.exp(-z_out)) # Sigmoid → 0.966
print(f"हिडन लेयर: h1={h1}, h2={h2}")
print(f"कच्चा आउटपुट: {z_out:.2f}")
print(f"स्पैम संभावना: {output:.1%}") # 96.6% → स्पैम! 🚫
बड़ी तस्वीर 🗺️
डेटा (पाठ 1) → एल्गोरिदम (पाठ 2) → न्यूरल नेटवर्क (पाठ 3)
📊 🧮 🧠
न्यूरल नेटवर्क इन्हें शक्ति देते हैं:
- 🗣️ ChatGPT — भाषा समझना और उत्पन्न करना
- 🎨 DALL-E / Midjourney — टेक्स्ट से इमेज बनाना
- 🚗 सेल्फ-ड्राइविंग कारें — सड़क देखना और समझना
- 🔬 AlphaFold — प्रोटीन संरचनाओं की भविष्यवाणी
🤯
न्यूरल नेटवर्क का बुनियादी विचार 1943 में प्रस्तावित हुआ — 80 साल से ज़्यादा पहले! लेकिन ये 2010 के दशक में ही व्यावहारिक हुए, जब हमारे पास पर्याप्त डेटा और तेज़ कंप्यूटर (GPU) आए।
सारांश 🎯
- कृत्रिम न्यूरॉन इनपुट प्राप्त करते हैं, वेट से गुणा करते हैं, जोड़ते हैं और एक्टिवेशन लगाते हैं
- न्यूरल नेटवर्क में तीन प्रकार की लेयर हैं: इनपुट, हिडन और आउटपुट
- एक्टिवेशन फ़ंक्शन नॉन-लीनियरिटी जोड़ते हैं — इनके बिना नेटवर्क सिर्फ सीधी रेखाएं सीख सकता है
- फॉरवर्ड प्रोपेगेशन डेटा को नेटवर्क से गुज़ारकर प्रेडिक्शन बनाता है
- बैकप्रोपेगेशन एरर को पीछे भेजकर वेट सुधारता है
- न्यूरल नेटवर्क आधुनिक AI को शक्ति देते हैं — चैटबॉट से सेल्फ-ड्राइविंग कारों तक
आगे क्या? 🚀
बधाई — अब आप AI के तीन स्तंभ समझते हैं: डेटा, एल्गोरिदम और न्यूरल नेटवर्क! आने वाले पाठों में हम AI टूल्स और ज़िम्मेदार AI के बारे में जानेंगे 🌱
Lesson 3 of 30 of 3 completed