एक LLM बनाएँमध्यमपाठ 385 मिनट का पाठ

स्टेप 2 · एम्बेडिंग्स और पोज़ीशन

टोकन ids को वेक्टर्स में बदलना, और मॉडल को यह बताना कि वे किस क्रम में आए थे। दो लुकअप टेबल, एक बारीक आइडिया।

पाठ वीडियो में

60 सेकंड में

स्टेप 2 · एम्बेडिंग्स और पोज़ीशन

टोकन ids को वेक्टर्स में बदलना, और मॉडल को यह बताना कि वे किस क्रम में आए थे। दो लुकअप टेबल, एक बारीक आइडिया।

1/4
आसान शब्दों में
हर शब्द-टुकड़े (word-chunk) को नंबरों की एक लिस्ट मिलती है, जैसे किसी नक्शे पर निर्देशांक (coordinates) हों। जिन टुकड़ों का मतलब एक जैसा होता है, वे नक्शे पर एक-दूसरे के पास पहुँच जाते हैं। मॉडल यह नक्शा खुद सीखता है।
टोकन id 15496 का गणित के हिसाब से कोई मतलब नहीं है — यह बस एक स्लॉट नंबर है। मॉडल सबसे पहला काम यह करता है कि इसके लिए सीखा हुआ एक वेक्टर ढूँढता है।
Embeddings, in three linespython
import torch, torch.nn as nn

vocab_size, d_model = 50257, 768
tok_emb = nn.Embedding(vocab_size, d_model)   # a (50257, 768) lookup table

ids = torch.tensor([[15496, 995, 0]])         # batch 1, sequence 3
x = tok_emb(ids)                              # -> (1, 3, 768)
बस इतना ही है। nn.Embedding एक मैट्रिक्स है जहाँ रो (row) i, टोकन i का वेक्टर होती है, और यह लुकअप डिफरेंशिएबल (differentiable) होता है, इसलिए ट्रेनिंग इन रो को तब तक इधर-उधर खिसकाती रहती है जब तक कि मिलते-जुलते टोकन एक-दूसरे के पास न आ जाएँ।

क्रम की समस्या

अटेंशन (Attention), जिससे आप अगले मॉड्यूल में मिलेंगे, उसे क्रम का कोई अंदाज़ा नहीं होता। उसे "dog bites man" और "man bites dog" दें और — बिना पोज़ीशन की जानकारी के — उसे वेक्टर्स का एक ही जैसा झोला दिखाई देता है। हमें पोज़ीशन अलग से जोड़नी ही पड़ती है।
तरीकायह कैसे काम करता हैकिसके द्वारा इस्तेमाल किया गया
सीखा हुआ ऐब्सोल्यूट (Learned absolute)एक दूसरी लुकअप टेबल जिसे पोज़ीशन 0,1,2… से इंडेक्स किया जाता हैGPT-2, BERT
साइनसॉइडल (Sinusoidal)अलग-अलग फ़्रीक्वेंसी की तय साइन (sine) और कोसाइन (cosine) तरंगेंओरिजिनल ट्रांसफ़ॉर्मर पेपर
RoPE (रोटरी)क्वेरी (query) और की (key) वेक्टर्स को पोज़ीशन के अनुपात वाले कोण (angle) पर घुमानाLlama, Mistral, Qwen, ज़्यादातर मॉडर्न मॉडल्स
ALiBiअटेंशन स्कोर्स में सीधे एक दूरी की पेनल्टी (distance penalty) जोड़नाकुछ लंबे-कॉन्टेक्स्ट वाले मॉडल्स

RoPE क्यों जीता

ऐब्सोल्यूट पोज़ीशन एम्बेडिंग्स मॉडल को सिखाती हैं "यह स्लॉट 7 है"। वहीं RoPE दो टोकन के बीच के अटेंशन स्कोर को इस बात पर निर्भर करता है कि वे एक-दूसरे से कितनी दूर हैं, जो कि भाषा में असल मायने रखता है। यह ट्रेनिंग में देखे गए किसी भी सीक्वेंस से ज़्यादा लंबे सीक्वेंसेज़ पर भी बहुत बेहतर तरीके से काम करता है (extrapolate करता है)।
Rotary position embeddingspython
def rope_frequencies(head_dim, seq_len, base=10000.0, device="cpu"):
    # one angular frequency per pair of dimensions
    inv = 1.0 / (base ** (torch.arange(0, head_dim, 2, device=device).float() / head_dim))
    pos = torch.arange(seq_len, device=device).float()
    ang = torch.outer(pos, inv)                 # (seq_len, head_dim/2)
    return torch.cos(ang), torch.sin(ang)

def apply_rope(x, cos, sin):
    # x: (batch, heads, seq, head_dim) -- rotate each adjacent pair of dims
    x1, x2 = x[..., 0::2], x[..., 1::2]
    cos, sin = cos[None, None], sin[None, None]
    out1 = x1 * cos - x2 * sin
    out2 = x1 * sin + x2 * cos
    return torch.stack((out1, out2), dim=-1).flatten(-2)
यह करें
इसे जियोमेट्री (रेखागणित) के नज़रिए से समझें। डायमेंशन के हर जोड़े को एक वृत्त (circle) पर एक बिंदु माना जाता है और उसकी पोज़ीशन के अनुपाती कोण पर घुमाया जाता है। जब आप बाद में पोज़ीशन m पर मौजूद क्वेरी और पोज़ीशन n पर मौजूद की (key) के बीच डॉट प्रोडक्ट निकालते हैं, तो रिज़ल्ट m − n पर निर्भर करता है — रिलेटिव दूरी गणित से अपने आप मुफ़्त में मिल जाती है।

एम्बेडिंग्स क्या नहीं हैं

  • वे मतलबों की कोई डिक्शनरी नहीं हैं। एक टोकन वेक्टर महज़ एक शुरुआत होती है जिसे बाद की हर लेयर कॉन्टेक्स्ट के हिसाब से दोबारा लिखती है।
  • मशहूर "king − man + woman ≈ queen" वाला हिसाब पुराने वर्ड-वेक्टर मॉडलों से आया था। ट्रांसफ़ॉर्मर टोकन एम्बेडिंग्स को अलग से समझ पाना कहीं ज़्यादा मुश्किल होता है।
  • एम्बेडिंग और आउटपुट लेयर्स अक्सर टाई (tied) होती हैं — यानी वही मैट्रिक्स, ट्रांस्पोज़ होकर, लॉगिट्स (logits) बनाती है। इससे पैरामीटर्स बचते हैं और आमतौर पर यह मददगार होता है।

और देखें और पढ़ें

Attention in transformers, visually3Blue1Brown · video

लैब

पोज़ीशन एनकोडिंग, और इसे हटाने पर होने वाली गड़बड़ी।

~15 min

समस्या

एक काम करने वाला छोटा ट्रांसफ़ॉर्मर लें। पोज़ीशन एनकोडिंग हटा दें और फिर से ट्रेन करें। लॉस के फ़र्क को मापें और देखें कि मॉडल अब क्या कर सकता है और क्या नहीं। फिर RoPE लागू करें और ट्रेन की गई लंबाई से आगे के नतीजों (extrapolation) की तुलना करें।
शुरुआती कोडpython
# Prove attention is permutation-invariant without positions
x = torch.randn(1, 5, 64)
perm = torch.randperm(5)
assert torch.allclose(attn(x).sum(1), attn(x[:, perm]).sum(1), atol=1e-5)
Google Colab खोलें ↗इस कोड के लिए आपके अपने सेटअप की ज़रूरत है (एक मॉडल, एक GPU या अतिरिक्त पैकेज)। इसे Google Colab में चलाएं: File → Upload notebook।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1RoPE फ़्रीक्वेंसीज़ को रीस्केल करने से बिना किसी रीट्रेनिंग के कॉन्टेक्स्ट बढ़ जाता है। यह काफ़ी क्यों नहीं है, और मॉडल में असल में किस चीज़ की कमी रह जाती है?दिखाएं
रीस्केल करने से लंबी पोज़ीशन्स दिखाने लायक (representable) बन जाती हैं — कोणों में अब टकराव (aliasing) नहीं होता — लेकिन मॉडल ने कभी इतनी दूरी पर फैला हुआ कोई संबंध देखा ही नहीं होता, इसलिए उसने ऐसा कोई अटेंशन पैटर्न सीखा ही नहीं है जो इसका इस्तेमाल करे। आपको लंबे इनपुट पर धाराप्रवाह आउटपुट तो मिलता है, लेकिन वह उसका सही इस्तेमाल नहीं कर पाता। जिस चीज़ की कमी है, वह है उस लंबाई पर ट्रेनिंग सिग्नल: वाकई लंबे दस्तावेज़ों पर लगातार प्रीट्रेनिंग, जहाँ जवाब दूर मौजूद कॉन्टेक्स्ट पर निर्भर करता हो।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

d_model कितना बड़ा होना चाहिए?

यह मॉडल के साथ बढ़ता है। मोटे तौर पर: सिखाने वाले एक छोटे से मॉडल के लिए 128–384, GPT-2 small के लिए 768, 7B मॉडल के लिए 4096, और सबसे बड़े (frontier) स्केल पर 8192+। यह अटेंशन हेड्स की संख्या से विभाज्य (divisible) होना चाहिए।

क्या ये सर्च के लिए इस्तेमाल होने वाली सेंटेंस एम्बेडिंग्स जैसी ही हैं?

एक ही नाम वाली अलग-अलग चीज़ें। रिट्रीवल (Retrieval) एम्बेडिंग्स पूरे पैसेज को एक वेक्टर के रूप में दिखाती हैं, जिसे समानता (similarity) के लिए ट्रेन किए गए मॉडल द्वारा बनाया जाता है। टोकन एम्बेडिंग्स किसी जनरेटिव मॉडल के लिए प्रति-टोकन इनपुट होती हैं।

छोटे मॉडल्स में एम्बेडिंग टेबल का दबदबा क्यों होता है?

50k की वोकैबुलरी और 768 d_model के साथ, अकेले वह टेबल ही 38M पैरामीटर्स की होती है। 100M-पैरामीटर वाले मॉडल में यह कुल का एक तिहाई हिस्सा होती है। यही वजह है कि छोटे मॉडल अक्सर छोटी वोकैबुलरी का इस्तेमाल करते हैं।

क्या मैं सीखे गए पोज़ीशन्स (learned positions) वाले मॉडल में RoPE जोड़ सकता हूँ?

काफ़ी दोबारा ट्रेनिंग (retraining) के बिना नहीं। पोज़ीशन एनकोडिंग इस बात में गहराई से रची-बसी होती है कि हर अटेंशन हेड ने क्या सीखा है। बदलने के तरीके मौजूद हैं और वे सभी अनुमानित (approximate) हैं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें