एक LLM बनाएँएडवांस्डपाठ 476 मिनट का पाठ

स्टेप 11 · मॉडर्न आर्किटेक्चर अपग्रेड्स

2019 के ट्रांसफ़ॉर्मर और 2026 के ट्रांसफ़ॉर्मर में क्या फर्क है। छह बदलाव—हर एक छोटा, लेकिन मिलकर बहुत बड़ा असर डालते हैं।

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

60 सेकंड में

स्टेप 11 · मॉडर्न आर्किटेक्चर अपग्रेड्स

2019 के ट्रांसफ़ॉर्मर और 2026 के ट्रांसफ़ॉर्मर में क्या फर्क है। छह बदलाव—हर एक छोटा, लेकिन मिलकर बहुत बड़ा असर डालते हैं।

1/4
आसान शब्दों में
वही कार, बेहतर पार्ट्स। इंजन का आकार कुछ नहीं बदला — बस पिस्टन हल्के हो गए और गियरबॉक्स ज़्यादा स्मार्ट हो गया।
बदलावकिसकी जगह लीक्यों
RoPEसीखे गए (Learned) पोज़िशन एम्बेडिंग्सरिलेटिव दूरी, बेहतर एक्सट्रापोलेशन
RMSNormLayerNormसस्ता, क्वालिटी में कोई नपा-तुला नुकसान नहीं
SwiGLUReLU/GELU MLPप्रति पैरामीटर बेहतर क्वालिटी
कोई बायस (bias) नहींहर जगह बायस टर्म्सकम पैरामीटर्स, ज़्यादा स्टेबल
GQAMulti-head attentionइनफ़रेंस के समय बहुत छोटा KV cache
MoEDense फ़ीड-फ़ॉरवर्डप्रति टोकन समान कंप्यूट में ज़्यादा पैरामीटर्स

ग्रुप्ड-क्वेरी अटेंशन: इनफ़रेंस का बड़ा फ़ायदा

जनरेशन के समय आप हर पिछले टोकन के लिए key और value वेक्टर्स को कैश करते हैं — जिसे KV cache कहते हैं। स्टैंडर्ड multi-head attention के साथ यह कैश बहुत विशाल होता है और सर्विंग के दौरान मेमोरी पर हावी हो जाता है।
GQA कई क्वेरी हेड्स को एक ही key-value हेड शेयर करने देता है। बत्तीस क्वेरी हेड्स के साथ आठ KV हेड्स कैश को लगभग बिना किसी क्वालिटी नुकसान के चार गुना कम कर देते हैं।
Grouped-query attentionpython
class GQA(nn.Module):
    def __init__(self, d_model, n_head, n_kv_head):
        super().__init__()
        self.n_head, self.n_kv = n_head, n_kv_head
        self.d_head = d_model // n_head
        self.rep = n_head // n_kv_head          # query heads per kv head
        self.q  = nn.Linear(d_model, n_head * self.d_head, bias=False)
        self.kv = nn.Linear(d_model, 2 * n_kv_head * self.d_head, bias=False)
        self.proj = nn.Linear(d_model, d_model, bias=False)

    def forward(self, x):
        B, T, C = x.shape
        q = self.q(x).view(B, T, self.n_head, self.d_head).transpose(1, 2)
        k, v = self.kv(x).view(B, T, 2, self.n_kv, self.d_head).unbind(2)
        k = k.transpose(1, 2).repeat_interleave(self.rep, dim=1)
        v = v.transpose(1, 2).repeat_interleave(self.rep, dim=1)
        y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
        return self.proj(y.transpose(1, 2).reshape(B, T, C))

मिक्सचर ऑफ़ एक्सपर्ट्स: ज़्यादा दिमाग, वही ख़र्च

एक फ़ीड-फ़ॉरवर्ड नेटवर्क की जगह कई नेटवर्क रखें, और हर टोकन को उनमें से सिर्फ़ दो-एक के पास भेजें। मॉडल में कहीं ज़्यादा पैरामीटर्स होते हैं, लेकिन हर टोकन केवल एक छोटे हिस्से को ही एक्टिवेट करता है, इसलिए प्रति टोकन कंप्यूट लगभग उतना ही रहता है।
TokenrouterExpert 1Expert 2Expert 3Expert 4… 60 moretop-2 onlyCombine400B total30B activeper token
टोटल पैरामीटर्स और एक्टिव पैरामीटर्स अलग-अलग संख्याएँ हैं। एक स्पार्स (sparse) मॉडल सैकड़ों अरबों पैरामीटर्स रख सकता है, जबकि उसका प्रति टोकन ख़र्च एक बहुत छोटे डेंस (dense) मॉडल जितना ही होता है।
MoE से आपको क्या मिलता है
  • प्रति टोकन समान कंप्यूट के लिए कहीं ज़्यादा नॉलेज कैपेसिटी।
  • दिए गए लॉस तक तेज़ी से ट्रेनिंग।
  • एक्सपर्ट्स ख़ास चीज़ों में माहिर हो जाते हैं, जिन्हें कभी-कभी आसानी से समझा भी जा सकता है।
MoE की क्या कीमत चुकानी पड़ती है
  • सभी पैरामीटर्स मेमोरी में होने चाहिए, यहाँ तक कि इनएक्टिव वाले भी — सर्विंग के लिए बहुत ज़्यादा VRAM चाहिए।
  • लोड बैलेंसिंग पेचीदा है; ऑक्ज़ीलरी लॉस के बिना कुछ ही एक्सपर्ट्स के पास सारा काम चला जाता है।
  • डिस्ट्रीब्यूट, फाइन-ट्यून और क्वांटाइज़ करना ज़्यादा मुश्किल है।
  • लेटेंसी में ज़्यादा उतार-चढ़ाव (वेरिएंस)।
सावधान रहें
पहले प्रोजेक्ट में MoE न जोड़ें। यह आपके रन के फ़ेल होने के तरीकों को कई गुना बढ़ा देता है, जबकि इसका फ़ायदा केवल बड़े पैमाने (स्केल) पर दिखता है। पहले एक डेंस मॉडल को शुरू से अंत तक ठीक से चला लें।

2026 के लिए एक समझदारी भरी डिफ़ॉल्ट कॉन्फ़िगरेशन

If you are starting freshpython
config = dict(
    norm="rmsnorm", norm_position="pre",
    position="rope", rope_theta=500000,     # large theta for long context
    ffn="swiglu", ffn_mult=8/3,
    attention="gqa", n_head=32, n_kv_head=8,
    bias=False,
    tie_embeddings=True,                    # for models under ~2B
    vocab_size=128256,
    dtype="bfloat16",
)

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

लैब

GQA लागू किया गया, और पहले व बाद में KV cache मापा गया।

~20 min

समस्या

ग्रुप्ड-क्वेरी अटेंशन लागू करें। MHA बनाम GQA-8 बनाम MQA के लिए 4k कॉन्टेक्स्ट पर MB में KV cache साइज़ मापें, और एक अलग रखे गए डेटासेट (held-out set) पर क्वालिटी का फ़र्क मापें।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

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

कठिन सवाल

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

Q1आपके टारगेट बैच साइज़ और कॉन्टेक्स्ट पर आपका KV cache 40GB है। हर उपाय और उसकी कीमत की लिस्ट बनाएँ।दिखाएं
GQA या MQA — 4-8 गुना कमी, क्वालिटी का थोड़ा सा नुकसान। int8 में KV cache क्वांटाइज़ेशन — 2 गुना कमी, एक्यूरेसी का थोड़ा सा नुकसान। छोटा कॉन्टेक्स्ट — मुफ़्त, लेकिन प्रोडक्ट की उपयोगिता में कमी। छोटा बैच — मुफ़्त, लेकिन थ्रूपुट का नुकसान। ज़्यादातर लेयर्स पर स्लाइडिंग-विंडो या लोकल अटेंशन — भारी कमी, लेकिन सटीक लंबी दूरी का रिकॉल छूट जाता है। Paged attention — कोई कमी नहीं लेकिन फ़्रैग्मेंटेशन हटाता है, अक्सर प्रभावी क्षमता 2 गुना हो जाती है। GQA और paged attention से शुरुआत करें; इनमें सबसे कम नुकसान होता है।

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

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

क्या मुझे MoE इस्तेमाल करना चाहिए?

केवल तभी जब आप अच्छे-खासे बड़े पैमाने पर ट्रेनिंग कर रहे हों और आपके पास सर्विंग मेमोरी हो। लगभग 10B एक्टिव पैरामीटर्स से कम की किसी भी चीज़ के लिए, डेंस मॉडल सरल है और आमतौर पर बेहतर इंजीनियरिंग विकल्प है।

क्या GQA से क्वालिटी पर असर पड़ता है?

बहुत हल्का, और प्रैक्टिस में यह लगभग मुफ़्त जैसा ही है। 4:1 या 8:1 का सामान्य क्वेरी-टू-KV हेड्स रेशियो बहुत बड़े सर्विंग फ़ायदे के बदले क्वालिटी में बहुत मामूली कमी दिखाता है। मल्टी-क्वेरी अटेंशन — यानी एक KV हेड — इससे भी आगे जाता है और उसमें क्वालिटी का थोड़ा और नुकसान होता है।

rope_theta क्या है और इसे क्यों बढ़ाया जाता है?

यह रोटेशन की बेस फ़्रीक्वेंसी सेट करता है। एक बड़ी वैल्यू पोज़िशन्स पर एंगल्स को ज़्यादा धीरे-धीरे फैलाती है, जिससे लंबे कॉन्टेक्स्ट का एक्सटेंशन बेहतर काम करता है। लंबे कॉन्टेक्स्ट को टारगेट करने वाले मॉडल्स आमतौर पर ओरिजिनल 10k के बजाय 500k या उससे ज़्यादा का इस्तेमाल करते हैं।

क्या ट्रांसफ़ॉर्मर्स के कोई असली विकल्प हैं?

Mamba जैसे स्टेट-स्पेस मॉडल्स लीनियर-टाइम इनफ़रेंस के साथ कुछ स्केल्स पर सचमुच बेहतरीन टक्कर देते हैं, और हाइब्रिड डिज़ाइन्स दोनों को बारी-बारी से जोड़ते हैं। प्रोडक्शन में अभी भी अटेंशन का ही बोलबाला है, लेकिन यह सबसे दिलचस्प एक्टिव रिसर्च एरिया है।

पाठ का टेस्ट

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

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