क्यों ट्रांसफार्मर आरएनएन के साथ समस्याएं
Type: Learn
Languages: Python
Prerequisites: Phase 3 (Deep Learning Core), Phase 5 · 09 (Sequence-to-Sequence), Phase 5 · 10 (Attention Mechanism)
Time: ~45 minutes
समस्या
2017 से पहले, ग्रह पर हर अत्याधुनिक अनुक्रम मॉडल भाषा, अनुवाद, भाषण एक आवर्ती तंत्रिका नेटवर्क था। एलएसटीएम और जीआरयू ने आधे दशक के लिए इमेजनेट के समकक्ष अनुवाद बेंचमार्क जीते। वे एकमात्र उपकरण थे जो किसी के पास था।
क्रमबद्ध गणना का मतलब है कि आप समय अक्ष के साथ समानांतर नहीं कर सकते थेः टोकनt+1टोकन से छिपे हुए राज्य की जरूरत है tएक 1,024 टोकन अनुक्रम का मतलब एक GPU पर 1,024 धारावाहिक चरणों है जो प्रति चक्र 1,000,000 फ्लोटिंग-पॉइंट ऑपरेशन कर सकते हैं। प्रशिक्षण दीवार घड़ी समय समानांतर के लिए डिज़ाइन हार्डवेयर पर अनुक्रम लंबाई के साथ रैखिक रूप से स्केल किया गया।
गायब होने के ग्रेडिएंट का मतलब है कि सूचना 50 टोकन वापस 50 गैर-रेखीयता के माध्यम से पहले से ही संपीड़ित की गई थी। गेट रिसीडेंट यूनिट (LSTM, GRU) ने क्रश को नरम कर दिया लेकिन इसे कभी खत्म नहीं किया। लंबी दूरी की निर्भरता "बुक जिसे मैंने पिछले गर्मियों में क्योटो के लिए एक विमान पर पढ़ा था ..." नियमित रूप से विफल रहा।
फिक्स्ड-विस्तार छिपे हुए राज्यों का मतलब है कि एन्कोडर ने स्रोत अनुक्रम को एक ही वेक्टर में दबाने से पहले डिकोडर ने कुछ भी देखा। इससे कोई फर्क नहीं पड़ता कि स्रोत 5 टोकन या 500 है; बोतल गला एक ही आकार है।
2017 के पेपर "ध्यान आपको बस इतना चाहिए" ने कुछ कट्टरपंथी प्रस्तावित कियाः पुनरावृत्ति को पूरी तरह से छोड़ दें। हर स्थिति को हर अन्य स्थिति पर समानांतर रूप से ध्यान देना चाहिए। 1,024 अनुक्रमिक के बजाय एक बड़े मैट्रिक्स गुणा में अभ्यास करें।
परिणाम 2026 तक हर मोडलिटी पर हावी होगा। भाषा (GPT-5, क्लाउड 4, लामा 4), दृष्टि (ViT, DINOv2, SAM 3), ऑडियो (विस्पर), जीव विज्ञान (अल्फाफोल्ड 3), रोबोटिक्स (RT-2) । एक ही ब्लॉक, अलग-अलग इनपुट।
अवधारणा
!RNN sequential compute vs Transformer parallel attention
Recurrence as a bottleneck.एक आरएनएन गणना करता है h_t = f(h_{t-1}, x_t). प्रत्येक कदम पिछले पर निर्भर करता है. आप गणना नहीं कर सकते .h_5पहलेh_410,000 से अधिक समानांतर कोरों के साथ आधुनिक जीपीयू पर, यह एक लंबे अनुक्रम पर सिलिकॉन का 99% बर्बाद करता है।
Attention as a broadcast.आत्म-ध्यान गणना output_i = sum_j(a_ij * v_j)प्रत्येक जोड़ी के लिए (i, j)एक ही समय में. पूरे N×N ध्यान मैट्रिक्स एक बैच मैटमुल भरता है. कोई कदम दूसरे पर निर्भर करता है. GPUs इसे प्यार करते हैं.
The speedup is not a constant.यह अंतर है O(N)सीरियल गहराई और O(1)सीरियल गहराई. व्यवहार में, ट्रांसफार्मर 510x प्रति युग पर 510x तेजी से N=512 पर मिलान हार्डवेयर पर ट्रेन करते हैं, और अंतर अनुक्रम की लंबाई के साथ बढ़ता है जब तक आप O(N²)ध्यान की स्मृति दीवार (जो फ्लैश ध्यान बाद में ठीक देखें पाठ 12) ।
What transformers cost.ध्यान स्मृति पैमाने के रूप में O(N²). 2K संदर्भ के लिए, ठीक है. 128K संदर्भ के लिए, आप स्लाइडिंग खिड़कियों, RoPE एक्सट्रापोलेशन, फ्लैश ध्यान टाइलिंग, या रैखिक ध्यान संस्करणों की जरूरत है. पुनरावृत्ति थाO(N)समय और स्मृति दोनों में; ट्रांसफार्मर समय को स्मृति के लिए व्यापार करते हैं और फिर समानांतरता के माध्यम से समय को वापस जीतते हैं।
The inductive bias shift.RNNs स्थानीयता और हालियापन का अनुमान लगाते हैं। ट्रांसफार्मर कुछ भी नहीं मानते हैं। प्रत्येक जोड़ी ध्यान के लिए उम्मीदवार है। यही कारण है कि ट्रांसफार्मर को अच्छी तरह से प्रशिक्षित करने के लिए अधिक डेटा की आवश्यकता होती है लेकिन एक बार जब वे इसे प्राप्त करते हैं तो आगे बढ़ते हैं। चिंचिला (2022) ने इसे औपचारिक रूप दियाः पर्याप्त टोकन दिए जाने पर, एक ट्रांसफार्मर हमेशा समान पैरामीटर की संख्या के RNN को हराता है।
इसे बनाओ
यहाँ कोई तंत्रिका नेटवर्क नहीं है हम संख्यात्मक रूप से कोर बोतल गला अनुकरण ताकि आप अपने लैपटॉप पर अंतर महसूस कर सकते हैं.
चरण 1: सीरियल गहराई मापें
देखोcode/main.py. हम दो फ़ंक्शन बनाते हैं. एक अनुक्रम को जोड़ों की श्रृंखला के रूप में एन्कोड करता है (सीरियल, जैसे आरएनएन) । एक इसे समानांतर कमी (प्रसारण, जैसे ध्यान) के रूप में एन्कोड करता है। एक ही गणित, अलग निर्भरता ग्राफ।
pythondef rnn_style(xs):
h = 0.0
for x in xs:
h = 0.9 * h + x # can't parallelize: h depends on previous h
return h
def attention_style(xs):
return sum(xs) / len(xs) # every x is independentहम 100,000 तत्वों तक के अनुक्रमों पर दोनों का समय बनाते हैं। RNN संस्करण O(N) और एक एकल सीपीयू पाइपलाइन है। शुद्ध पायथन में भी, ध्यान शैली में कमी इसे लंबाई ≥ 1,000 से अधिक है क्योंकि पायथन की sum()C में लागू किया जाता है और प्रति चरण अनुवादक ओवरहेड के बिना दोहराता है।
चरण 2: सैद्धांतिक संचालन की गणना करें
दोनों एल्गोरिदम N जोड़ते हैं। अंतर निर्भरता गहराई हैः अगले शुरू होने से पहले अनुक्रमिक रूप से कितने ऑपरेशन होने चाहिए। RNN गहराई = N। ध्यान गहराई = log(N) के साथ एक पेड़ की कमी, या 1 के साथ समानांतर स्कैन। गहराई, न कि ऑपरेशन गिनती, GPU समय तय करती है।
चरण 3: लंबी अनुक्रमों पर अनुभवजन्य पैमाने
हम एक समय सारणी प्रिंट करते हैं जो ओ ((एन) अंतर को दिखाई देता है। 2026 मैक लैपटॉप पर, 1,000 तत्वों के तहत अनुक्रम मापने के लिए बहुत तेज़ हैं। 100,000 के अनुक्रम एक स्वच्छ रैखिक स्कैन दिखाते हैं। 12 परतों के LSTM समकक्ष के साथ 16,384-टोकन ट्रांसफार्मर के लिए इसे मापें और आप देखेंगे कि 2016 में प्रशिक्षण दीवार घड़ी एक ब्लॉकर क्यों थी।
इसका प्रयोग करें
2026 में आरएनएन को कब चुनना हैः
| Situation | Pick |
|---|---|
| Streaming inference, one token at a time, constant memory | RNN or state-space model (Mamba, RWKV) |
| Very long sequences (>1M tokens) where attention memory explodes | Linear attention, Mamba 2, Hyena |
| Edge device with no matmul accelerator | Depthwise-separable RNN still wins on FLOPs/watt |
| Anything else (training, batched inference, context up to 128K) | Transformer |
Mamba जैसे राज्य-अंतरिक्ष मॉडल (SSM) अनिवार्य रूप से संरचित पैरामीटर के साथ RNNs हैं जो उन्हें दोनों का सर्वश्रेष्ठ देता हैः O(N)स्कैन मेमोरी, चयनात्मक स्कैन के माध्यम से समानांतर प्रशिक्षण। वे बेहतर दीर्घ-संदर्भ स्केलिंग के साथ ट्रांसफार्मर की गुणवत्ता का 90% पुनर्प्राप्त करते हैं। 2026 में अधिकांश सीमा प्रयोगशालाएं हाइब्रिड एसएसएम+ ट्रांसफार्मर मॉडल (जैसे जाम्बा, सांबा) पुनरावृत्ति मृत नहीं है, यह एक घटक है।
इसे भेजें
देखोoutputs/skill-architecture-picker.md. कौशल एक नई अनुक्रम समस्या के लिए एक वास्तुकला चुनता है लंबाई, पारगमन, और प्रशिक्षण-बजट प्रतिबंधों को देखते हुए। यह हमेशा ट्रेनिंग रन के लिए एक शुद्ध RNN की सिफारिश करने से इनकार करना चाहिए 1B टोकन से ऊपर के लिए व्यापार-बंदियों का उल्लेख किए बिना।
व्यायाम
- Easy.ले लो
rnn_styleसेcode/main.pyऔर छिपे हुए राज्यों की लंबाई-64 वेक्टर के साथ स्केलर छिपे हुए राज्य की जगह लें। फिर से मापें। छिपे हुए राज्य के आयाम के साथ सीरियल ओवरहेड कितना बढ़ता है? - Medium.शुद्ध पायथन में समानांतर पूर्वावलोकन-समुच्चय (हिलिस-स्टील स्कैन) लागू करें। यह सत्यापित करें कि यह लंबाई 1024 पर एक सीरियल स्कैन के समान संख्यात्मक आउटपुट का उत्पादन करता है। गहराई गिनें।
- Hard.ध्यान शैली में कमी को पीआईटॉर्च पर जीपीयू पर पोर्ट करें। समय दोनों जब आप 64 से क्रम लंबाई को 65 536 तक जाप करते हैं। प्लॉट और वक्र के आकार की व्याख्या करें।
प्रमुख शर्तें
| Term | What people say | What it actually means |
|---|---|---|
| Recurrence | "RNNs are sequential" | Computation where step t depends on step t-1, forcing serial execution along the time axis. |
| Serial depth | "How deep the graph is" | Longest chain of dependent ops; bounds wall-clock even on infinite hardware. |
| Attention | "Let tokens look at each other" | Weighted sum sum_j a_ij v_j where a_ij comes from a similarity score between positions i and j. |
| Context window | "How much the model sees" | Number of positions an attention layer can take as input; quadratic memory cost scales here. |
| Inductive bias | "Assumptions baked into the architecture" | Prior about what the data looks like; CNNs assume translation invariance, RNNs assume recency. |
| State-space model | "RNN with algebra behind it" | Recurrence parameterized for parallel training via structured state-space matrices. |
| Quadratic bottleneck | "Why context costs so much" | Attention memory = O(N²) in sequence length; Flash Attention hides the constants, not the scaling. |
आगे पढ़ना
- Vaswani et al. (2017). Attention Is All You Need पेपर जो मुख्यधारा के एनएलपी में पुनरावृत्ति को मारता है।
- Bahdanau, Cho, Bengio (2014). Neural MT by Jointly Learning to Align and Translate जहां ध्यान का जन्म हुआ, एक आरएनएन पर बुल्ट किया गया।
- Hochreiter, Schmidhuber (1997). Long Short-Term Memory मूल LSTM पेपर, रिकॉर्ड के लिए।
- Gu, Dao (2023). Mamba: Linear-Time Sequence Modeling with Selective State Spaces ट्रांसफार्मर के लिए आधुनिक आवर्ती उत्तर।
This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.
Browse the complete course catalog or open this lesson on GitHub.