AI Branches में आपने सीखा कि न्यूरल नेटवर्क में लेयर्स होती हैं। एक या दो हिडन लेयर्स वाला नेटवर्क शैलो कहलाता है। और अधिक लेयर्स जोड़ें - 10, 50, 100+ - और आपके पास एक डीप न्यूरल नेटवर्क है।
हर लेयर एक अलग एब्स्ट्रैक्शन लेवल सीखती है:
लेयर 1 → किनारे और सरल बनावट
लेयर 2 → कोने और आकृतियाँ
लेयर 3 → वस्तुओं के भाग (आँखें, पहिये)
लेयर 4 → पूरी वस्तुएँ (चेहरे, कारें)
लेयर 5+ → दृश्य और संदर्भ
कल्पना करें कि आप एक किताब पढ़ रहे हैं। लेयर 1 अक्षर पहचानती है, लेयर 2 शब्द, लेयर 3 वाक्य समझती है, और लेयर 4 पूरा अर्थ समझती है। लेयर 1 पर अटका एक शैलो पाठक केवल अक्षर देखेगा - कहानी कभी नहीं समझेगा।
शुरुआती शोधकर्ताओं ने कई लेयर्स स्टैक करने की कोशिश की, लेकिन ट्रेनिंग विफल होती रही। कारण: वैनिशिंग ग्रेडिएंट। बैकप्रोपेगेशन में, एरर सिग्नल हर लेयर से गुजरते हुए 0 और 1 के बीच की संख्याओं से गुणा होते हैं, जब तक सिग्नल लगभग शून्य नहीं हो जाता।
1. ReLU एक्टिवेशन - पॉजिटिव इनपुट के लिए ग्रेडिएंट बिल्कुल 1 है।
2. स्किप कनेक्शन - सिग्नल लेयर्स को छोड़ सकता है।
x ──→ [लेयर] ──→ (+) ──→ आउटपुट
│ ↑
└─────────────────┘ ← स्किप कनेक्शन
3. बैच नॉर्मलाइज़ेशन - हर लेयर के इनपुट को नॉर्मलाइज़ करता है।
इन खोजों से पहले, 10 से अधिक लेयर्स वाले नेटवर्क को ट्रेन करना लगभग असंभव था। इसके बाद, शोधकर्ताओं ने 1,000 से अधिक लेयर्स वाले नेटवर्क सफलतापूर्वक ट्रेन किए!
ResNet ने स्किप कनेक्शन पेश किए और 152-लेयर नेटवर्क के साथ ImageNet जीता। हर ब्लॉक रेज़िड्यूअल सीखता है - जो है और जो चाहिए उसके बीच का अंतर।
Transformer आर्किटेक्चर ने अनुक्रमिक प्रोसेसिंग को सेल्फ-अटेंशन मैकेनिज़म से बदल दिया। टेक्स्ट को शब्द-दर-शब्द पढ़ने के बजाय, यह सभी शब्दों को एक साथ देखता है।
"बिल्ली चटाई पर बैठी क्योंकि वह थकी हुई थी"
सेल्फ-अटेंशन पूछता है: "वह" किसे संदर्भित करता है?
"वह" ←→ "बिल्ली" (उच्च स्कोर: 0.82)
"वह" ←→ "चटाई" (निम्न स्कोर: 0.11)
Sign in to join the discussion
Transformers GPT, Claude, Llama और लगभग हर आधुनिक LLM के पीछे की आर्किटेक्चर है। अगली लेसन में हम गहराई से जानेंगे।
शुरू से एक डीप नेटवर्क ट्रेन करने के लिए लाखों उदाहरण चाहिए। ट्रांसफर लर्निंग आपको यह काम छोड़ने देता है: पहले से ट्रेन किया मॉडल लें और उसे अपने डेटा पर फाइन-ट्यून करें।
चरण 1: पूर्व-प्रशिक्षित मॉडल से शुरू करें
चरण 2: शुरुआती लेयर्स को फ्रीज़ करें
चरण 3: अंतिम लेयर को अपने कार्य से बदलें
चरण 4: केवल अंतिम लेयर्स को ट्रेन करें
चरण 5: कम डेटा और समय में उच्च सटीकता!
ट्रांसफर लर्निंग एक अनुभवी शेफ की तरह है जो फ्रेंच से जापानी कुकिंग में बदलता है। उसे चाकू पकड़ना फिर से नहीं सीखना - वे कौशल स्थानांतरित होते हैं।
न्यूरल नेटवर्क ट्रेनिंग मुख्य रूप से मैट्रिक्स गुणन है। CPU एक समय में कुछ ऑपरेशन करते हैं। GPU हजारों एक साथ करते हैं।
model = load_pretrained_model("resnet50")
for layer in model.layers:
layer.trainable = False
model.final_layer = DenseLayer(input_size=2048, output_size=3)
model.final_layer.trainable = True
train_data = load_images("flowers/train/", categories=["गुलाब", "सूरजमुखी", "ट्यूलिप"])
val_data = load_images("flowers/val/", categories=["गुलाब", "सूरजमुखी", "ट्यूलिप"])
model.compile(optimizer="adam", loss="cross_entropy", learning_rate=0.001)
model.fit(train_data, validation_data=val_data, epochs=5)
accuracy = model.evaluate(val_data)
print(f"वैलिडेशन सटीकता: {accuracy:.1%}")
देखें कितना कम डेटा चाहिए! ट्रांसफर लर्निंग बिना विशाल डेटासेट के भी डीप लर्निंग को सुलभ बनाता है।
अगली लेसन में हम लार्ज लैंग्वेज मॉडल्स में गहराई से उतरेंगे - ChatGPT, Claude और AI क्रांति के पीछे के इंजन। 📝