नए मॉडल बनाने के लिए आपको PyTorch को संशोधित करने की आवश्यकता नहीं है
मुख्य विचार
जब आप एक नया न्यूरल नेटवर्क आर्किटेक्चर बनाते हैं, तो आप अपना स्वयं का मॉडल कोड लिखते हैं। आप स्वयं PyTorch को नहीं छूते।
इसे खाना पकाने की तरह समझें: आप कोई नई रेसिपी बनाने के लिए अपने ओवन को संशोधित नहीं करते हैं। आप बस ओवन का अलग तरह से उपयोग करें।
दो अलग-अलग परतें
🟢 आपका मॉडल कोड (जिस पर आप हमेशा काम करते हैं)
यह वह जगह है जहां आप अपना आर्किटेक्चर बनाते हैं:
टॉर्च.एनएन को एनएन के रूप में आयात करें
क्लास MyCustomModel(nn.मॉड्यूल):
def __init__(स्वयं):
सुपर().__init__()
# PyTorch बिल्डिंग ब्लॉक्स को मिक्स एंड मैच करें
स्व.लेयर1 = एनएन.रैखिक(100, 64)
स्व.लेयर2 = एन.एन.रैखिक(64, 32)
self.custom_attention = MyAttention() # ← आपका आविष्कार!
डीईएफ़ फॉरवर्ड(स्वयं, एक्स):
x = self.layer1(x)
x = self.custom_attention(x) # ← आपका कस्टम तर्क
x = self.layer2(x)
वापसी एक्स
यही वह जगह है जहां सारा नवप्रवर्तन होता है।
🔴 पाइटोरच कोर (जिसे आप लगभग कभी नहीं छूते)
यह हुड के नीचे का इंजन है:
- जीपीयू पर मैट्रिक्स गुणन कैसे चलता है
- बैकप्रोपेगेशन के पीछे का गणित
- निम्न-स्तरीय CUDA संचालन
आप इसे केवल अत्यधिक प्रदर्शन अनुकूलन के लिए संशोधित करते हैं (शायद परियोजनाओं का 0.1%)।
वास्तविक उदाहरण: कस्टम ध्यान
मान लीजिए कि आपने एक नए ध्यान तंत्र का आविष्कार किया है। यहाँ प्रसिद्ध सूत्र है:
आप इसे PyTorch बिल्डिंग ब्लॉक्स का उपयोग करके कार्यान्वित करते हैं:
क्लास सिंपलअटेंशन(एनएन.मॉड्यूल):
def __init__(स्वयं, मंद):
सुपर().__init__()
स्व.स्केल = मंद ** -0.5
डीईएफ़ फॉरवर्ड (स्वयं, क्वेरी, कुंजी, मान):
# ध्यान स्कोर की गणना करें
स्कोर = टॉर्च.मैटमूल(क्वेरी, कुंजी.ट्रांसपोज़(-1, -2)) * सेल्फ.स्केल
# सॉफ्टमैक्स लगाएं
attn_weights = मशाल.सॉफ्टमैक्स(स्कोर, मंद=-1)
# मूल्यों पर लागू करें
आउटपुट = टॉर्च.मैटमुल(attn_weights, मान)
वापसी आउटपुट
हो गया! कोई PyTorch संशोधन की आवश्यकता नहीं है। आपने मौजूदा ऑपरेशन्स (torch.matmul, torch.softmax) का नए तरीके से उपयोग किया।
हर शोध पत्र कैसे काम करता है
| मशहूर मॉडल | उन्होंने क्या किया | संशोधित PyTorch? |
|---|---|---|
| रेसनेट | स्किप कनेक्शन जोड़े गए | ❌ नहीं |
| बर्ट | स्टैक्ड ट्रांसफार्मर अलग-अलग | ❌ नहीं |
| विज़न ट्रांसफार्मर | छवि पैच पर ट्रांसफार्मर लागू | ❌ नहीं |
| जीपीटी | डिकोडर-केवल आर्किटेक्चर | ❌ नहीं |
उन सभी ने बस चतुर एनएन.मॉड्यूल कक्षाएं लिखीं!
उदाहरण: "गेटेड अवशिष्ट ब्लॉक" का आविष्कार
कहें कि आपके पास एक नया विचार है:
क्लास GatedResidualBlock(nn.Module):
"""आपका नया आविष्कार!"""
def __init__(स्वयं, मंद):
सुपर().__init__()
self.conv = nn.Conv2d(मंद, मंद, 3, पैडिंग=1)
self.gate = nn.Conv2d(मंद, मंद, 1) # जानें कि क्या रखना है
डीईएफ़ फॉरवर्ड(स्वयं, एक्स):
अवशिष्ट = x
x = self.conv(x)
गेट = टॉर्च.सिग्मॉइड(सेल्फ.गेट(x)) # 0 से 1
वापसी अवशिष्ट + गेट * x # गेटेड स्किप कनेक्शन
यह नया वास्तुकला अनुसंधान है, जो केवल मौजूदा PyTorch संचालन का उपयोग करता है।
आप PyTorch को कब संशोधित करते हैं?
केवल तभी जब आपको किसी विशिष्ट ऑपरेशन के लिए तेज गति की आवश्यकता हो:
# कोई व्यक्ति तेजी से ध्यान आकर्षित करने के लिए एक कस्टम CUDA कर्नेल लिखता है
# (यह C++/CUDA है, बहुत उन्नत)
आयात my_fast_kernel # C++ से संकलित
क्लास माईमॉडल(एनएन.मॉड्यूल):
डीईएफ़ फॉरवर्ड(स्वयं, एक्स):
# अनुकूलित ऑपरेशन का उपयोग करें
my_fast_kernel.fast_attention(x) वापस करें
लेकिन यहां तक कि सबसे तेज़ मॉडल (जैसे GPT-4) भी ज़्यादातर nn.Module के साथ Python में लिखे गए हैं!
सरल सत्य
┌────────────────────────────┐
│ आपका मॉडल (पायथन) │ ← आप 99% समय यहां काम करते हैं
│ क्लास MyModel(nn.Module) │
├────────────────────────────┤
│ PyTorch बिल्डिंग ब्लॉक्स │ ← आप इनका उपयोग करें
│ nn.रैखिक, nn.Conv2d... │
├────────────────────────────┤
│ PyTorch इंजन (C++) │ ← इसे शायद ही कभी छूएं
│ जीपीयू संचालन, ऑटोग्रैड │
└────────────────────────────┘
त्वरित जांच सूची
जोड़ना चाहते हैं:
- ✅ नई परत के प्रकार? → एक नया
nn.Moduleलिखें - ✅ विभिन्न कनेक्शन? → अपना
फॉरवर्ड()बदलें - ✅ नवीन वास्तुकला? → मौजूदा परतों की रचना करें
- ✅ कस्टम हानि? → एक पायथन फ़ंक्शन लिखें
- ❌ तेज़ मैट्रिक्स गुणा? → अब आप PyTorch को संशोधित करेंगे (दुर्लभ!)
निचली पंक्ति
PyTorch आपको लेगो ब्लॉक देता है। आप उन्हें नए तरीकों से एक साथ जोड़कर जो चाहें बना सकते हैं।
महल बनाने के लिए आपको लेगो प्लास्टिक फॉर्मूला को संशोधित करने की आवश्यकता नहीं है। 🏰
बस इतना ही! आपकी रचनात्मकता आपके कोड में रहती है, ढांचे में नहीं।