ट्रांसफॉर्मर पर सोचना शुरू करने के लिए डॉक्टरेट की ज़रूरत नहीं। ज़रूरत है एक ऐसे मानसिक मॉडल की जो प्रोडक्शन में टिके: लंबे प्रॉम्प्ट पर लैटेंसी क्यों उछलती है, सीपीयू से पहले वीरैम क्यों मरता है, और "१२८के कॉन्टेक्स्ट" मुफ़्त क्यों नहीं है।
यही वह नक्शा है। कोई पेपर-सार नहीं। कोई हाइप नहीं। सिर्फ़ वे हिस्से जिन्हें आप एपीआई कॉल करते, लोकल मॉडल चलाते, या इन्फरेंस सर्वर डिबग करते समय असल में छूते हैं।
एक पंक्ति में
ट्रांसफॉर्मर टोकनों की श्रृंखला को अगले टोकन की भविष्यवाणी में बदलता है, बार-बार हर टोकन को दूसरे टोकनों (या उनकी सीमित खिड़की) को देखने देता है, फिर उन संकेतों को घने लेयरों से मिलाता है।
बाकी सब इसी विचार के इर्द-गिर्द इंजीनियरिंग है: टोकन कैसे दर्शाए जाएं, स्टैक कितना गहरा हो, कितना इतिहास रखा जाए, और हर नए टोकन पर काम दोबारा न गिनना पड़े।
टोकन और एम्बेडिंग: अलग-अलग पाठ सदिश बन जाता है
मॉडल शब्द नहीं देखते। वे टोकन देखते हैं, यानी पाठ के टुकड़े (उप-शब्द, पूरे शब्द, विरामचिह्न, कभी-कभी बाइट)। टोकनाइज़र वह उबाऊ प्लंबिंग है जो लागत के अनुमान बनाती या बिगाड़ती है। एक ही अंग्रेज़ी वाक्य एक मॉडल परिवार में १२ टोकन और दूसरे में २० हो सकता है।
हर टोकन आईडी एक सीखे हुए सदिश से जुड़ती है: एम्बेडिंग। इसे vocab_size x d_model आकार की लुकअप टेबल समझें। शुरुआती लेयरें इन सदिशों को निखारती हैं; बाद की लेयरें उन्हें संदर्भ से मिलाती हैं जब तक अंतिम सदिश अगले टोकन (या वर्गीकरण हेड) के लिए उपयोगी न हो जाए।
स्थिति मायने रखती है। शुद्ध अटेंशन में पहले से क्रम नहीं होता, इसलिए मॉडल स्थिति जानकारी जोड़ते हैं (पूर्ण स्थिति, सापेक्ष बायस, रोटरी एम्बेडिंग जैसे रोपी, और संबंधित रूप)। सूत्र याद रखने की ज़रूरत नहीं। निहितार्थ याद रखें: लंबी श्रृंखलाएं गणना और स्थिति-कोडिंग दोनों पर दबाव डालती हैं।
"Transformers are useful."
|
[tokenizer]
|
[tok1, tok2, tok3, tok4, ...]
|
[embedding + position]
|
matrix of shape [seq_len, d_model]
अटेंशन: उपयोगी अंतर्ज्ञान (मैट्रिक्स बीजगणित नहीं)
अटेंशन का जवाब है: इस टोकन के लिए अभी किन अन्य टोकनों को सुनना चाहिए?
हर स्थिति पर मॉडल मौजूदा हिडन स्टेट से तीन प्रोजेक्शन बनाता है:
| नाम | भूमिका (इंजीनियरिंग अंतर्ज्ञान) |
|---|---|
| क्वेरी (क्यू) | मैं क्या ढूंढ रहा हूँ? |
| की (के) | मैं क्या घोषित करता हूँ कि मेरे पास है? |
| वैल्यू (वी) | चुनने पर मैं कौन-सी सामग्री आगे भेजूँ? |
क्यू और के की समानता भार तय करती है। वे भार वी सदिशों को मिलाकर उस स्थिति का नया निरूपण बनाते हैं। मल्टी-हेड अटेंशन इनमें से कई समानांतर चलाता है ताकि एक हेड वाक्य-रचना पकड़े और दूसरा नाम, संख्या या कोड संरचना। बंटवारा मॉडल सीखता है। आप मुख्यतः यह देखते हैं कि हेड मेमोरी और मैटमल खर्च करते हैं।
कारण अटेंशन (डिकोडर) भविष्य को मास्क करता है: टोकन t केवल 1..t देख सकता है। इसी से बाएँ-से-दाएँ जनरेशन वैध बनती है। द्विदिश अटेंशन (एनकोडर) हर टोकन को पूरी इनपुट देखने देता है; क्लासिक बर्ट-शैली समझ कार्यों में यही था।
छोटे प्रॉम्प्ट की ठोस तस्वीर:
Tokens: [The] [cat] [sat] [on] [the] [mat]
"sat" के बाद भविष्यवाणी करते समय:
"sat" देख सकता है: The, cat, sat
"sat" नहीं देख सकता: on, the, mat (causal mask)
प्रसिद्ध लागत: सादा पूर्ण अटेंशन श्रृंखला लंबाई में ओ(एन²) है, गणना और अटेंशन स्कोर भंडारण दोनों में। कॉन्टेक्स्ट दोगुना करें तो अटेंशन काम लगभग ४ गुना (स्मार्ट कर्नल और सन्निकटन से पहले)। इसीलिए लंबा कॉन्टेक्स्ट एक साथ उत्पाद सुविधा और सिस्टम समस्या है।
एनकोडर, डिकोडर, और वे मॉडल जो आप सच में इस्तेमाल करते हैं
मूल २०१७ ट्रांसफॉर्मर पेपर अनुवाद के लिए एनकोडर-डिकोडर स्टैक इस्तेमाल करता था: एनकोडर स्रोत वाक्य पूरा पढ़ता है, डिकोडर लक्ष्य बनाता है कारण अटेंशन के साथ-साथ एनकोडर स्टेट पर क्रॉस-अटेंशन से।
कामकाजी इंजीनियर के लिए आज का नक्शा व्यवहार में सरल है:
| परिवार | पैटर्न | सामान्य उपयोग |
|---|---|---|
| केवल एनकोडर | द्विदिश स्टैक | वर्गीकरण, एम्बेडिंग, नाम-इकाई पहचान (बर्ट-शैली) |
| केवल डिकोडर | कारण स्टैक | चैट, कोड, एजेंट, अधिकांश फ्रंटियर एलएलएम |
| एनकोडर-डिकोडर | दोनों स्टैक | अनुवाद, कुछ सारांश / सीक्-टू-सीक् कार्य |
उत्पाद कार्य में २०२५-२०२६ में जब लोग "एलएलएम" कहते हैं, लगभग हमेशा मतलब केवल-डिकोडर ट्रांसफॉर्मर से है जो अगला टोकन भविष्यवाणी करने के लिए प्रशिक्षित हुआ, फिर निर्देश-ट्यूनिंग और अलाइनमेंट से गुज़रा। केवल-एनकोडर अभी भी रिट्रीवल एम्बेडिंग और क्लासिकल भाषा-पाइपलाइन में मायने रखते हैं। एनकोडर-डिकोडर विशेष सीक्-टू-सीक् काम में। अटेंशन गणित साझा है; मास्क और प्रशिक्षण उद्देश्य अलग हैं।
स्टैक गहराई, चौड़ाई (d_model), हेड संख्या, और फीड-फॉरवर्ड विस्तार अनुपात पैरामीटर गिनती तय करते हैं। ज़्यादा पैरामीटर बेहतर गुणवत्ता दे सकते हैं, लेकिन लोड करने को ज़्यादा वज़न और प्रति टोकन ज़्यादा गणना भी।
"कॉन्टेक्स्ट विंडो" असल में क्या है
कॉन्टेक्स्ट विंडो वह अधिकतम टोकन संख्या है जिस पर मॉडल एक फॉरवर्ड पास में अटेंशन कर सकता है (प्रॉम्प्ट + अब तक बने टोकन, उत्पाद कैसे गिने इस पर निर्भर)।
यह नहीं है:
- आपके ऐप के लिए असीमित मुफ़्त मेमोरी
- गारंटी कि मॉडल लंबे प्रॉम्प्ट के बीच का हिस्सा अच्छी तरह इस्तेमाल करेगा
- "प्रशिक्षण डेटा आकार" के बराबर
यह है:
- आर्किटेक्चर और उत्पाद की कठोर सीमा (कॉन्फ़िग + प्रशिक्षित स्थितियाँ + सर्विंग नीति)
- सिस्टम प्रॉम्प्ट, रिट्रीव्ड दस्तावेज़, चैट इतिहास, टूल ट्रेस और जवाब के बीच साझा बजट
- लागत और लैटेंसी का चालक, क्योंकि अटेंशन और केवी भंडारण टोकनों के साथ बढ़ते हैं
| कॉन्टेक्स्ट में क्या डालते हैं | क्या खर्च होता है |
|---|---|
| सिस्टम निर्देश | हर अनुरोध पर स्थिर आधार टोकन |
| रैग खंड | अक्सर सबसे बड़ी चर राशि |
| बहु-मोड़ इतिहास | काटने या सारांश तक बढ़ता रहता है |
| टूल कॉल / जेसन ट्रेस | आसानी से कम आँका जाता है |
| मॉडल का अपना आउटपुट | बनते समय विंडो में गिना जाता है |
व्यावहारिक नियम: कॉन्टेक्स्ट को वर्किंग सेट मानें, कचरा-डंप नहीं। रिट्रीवल गुणवत्ता "अभी के लिए २० और पन्ने" ठूँसने से जीतती है। लंबे-कॉन्टेक्स्ट मॉडल मदद करते हैं, लेकिन खराब प्रॉम्प्टिंग या लापरवाह रिट्रीवल को रद्द नहीं करते।
टोकनाइज़र बेमेल भी देखें। बिलिंग और सीमाएँ टोकन में हैं, शब्दों या अक्षरों में नहीं। यूयूआईडी और बेस६४ भरे लॉग डंप विंडो को चौंकाने वाली तेज़ी से जला सकते हैं।
इन्फरेंस में केवी कैश क्यों मायने रखता है
प्रशिक्षण और प्रीफ़िल एक कहानी है। संवादात्मक जनरेशन दूसरी।
जब आप टोकन-दर-टोकन बनाते हैं, सादा क्रियान्वयन हर नए टोकन पर पूरे प्रीफ़िक्स पर पूरा मॉडल दोबारा चलाएगा। सही है, और बेहद महँगा।
केवी कैश हर लेयर पर बीते टोकनों के पहले से गिने की और वैल्यू टेंसर रखता है। नए टोकन के लिए आप सिर्फ़ उसका क्यू/के/वी गिनते हैं, कैश किए के/वी इतिहास पर अटेंशन करते हैं, और नया के/वी जोड़ देते हैं।
Prefill (prompt once):
for each prompt token: compute K, V → store in cache
produce first output distribution
Decode (one token at a time):
compute Q, K, V for new token only
attend to cached K, V (+ new)
append new K, V
sample / argmax next token
repeat
इंजीनियर क्यों ध्यान दें:
१. लैटेंसी का आकार: प्रीफ़िल अक्सर गणना-भारी और प्रॉम्प्ट पर समानांतर होता है। डिकोड अक्सर मेमोरी-बैंडविड्थ बाध्य होता है क्योंकि आप वज़न और बढ़ते कैश को छोटे बैच (अक्सर १) के साथ स्ट्रीम करते हैं।
२. वीरैम: कैश आकार layers x heads x seq_len x head_dim x precision (और बैच) के साथ बढ़ता है। लंबी बातें और बड़े बैच वज़न फिट होने पर भी मेमोरी फोड़ देते हैं।
३. थ्रूपुट: कंटीन्यूअस बैचिंग और पेज्ड अटेंशन (प्रोडक्शन सर्विंग स्टैक में लोकप्रिय सिस्टम विचार) काफ़ी हद तक केवी लेआउट संभालने और विखंडन रोकने के लिए हैं।
४. बहु-मोड़ एपीआई: सर्वर पर "बातचीत की स्थिति" अक्सर "केवी रखो या फिर बनाओ" होती है। इसलिए कुछ प्लेटफ़ॉर्म जब प्रीफ़िक्स दोबारा इस्तेमाल कर सकें तो कैश किए इनपुट टोकन का शुल्क ताज़ा से अलग रखते हैं।
मेमोरी दबाव का मोटा मॉडल:
| लीवर | केवी कैश पर असर |
|---|---|
| लंबा प्रॉम्प्ट / इतिहास | seq_len में रैखिक वृद्धि |
| बड़ा बैच (समकालिक उपयोगकर्ता) | बैच में रैखिक वृद्धि |
| ज़्यादा लेयर / हेड / चौड़ाई | मॉडल आकार में रैखिक |
| एफपी१६ → एफपी८ / आईएनटी८ / क्वांटाइज़्ड केवी | प्रति तत्व बाइट घटते हैं (गुणवत्ता अलग-अलग) |
| स्लाइडिंग विंडो / विरल अटेंशन | कितनी दूर देखें सीमित; कैश बाँध सकता है |
अगर बातचीत के बीच जीपीयू मेमोरी खत्म करे, वज़न हमेशा अपराधी नहीं। कैश अक्सर अपराधी होता है।
सब जोड़कर: एक अनुरोध का जीवनचक्र
१. प्रॉम्प्ट टोकनाइज़ करें। २. टोकनों को एम्बेड करें और स्थिति जोड़ें। ३. एन ट्रांसफॉर्मर ब्लॉकों से प्रीफ़िल (हर ब्लॉक में अटेंशन + फीड-फॉरवर्ड), केवी कैश बनाते हुए। ४. अंतिम लॉगिट से अगला टोकन सैंपल करें (तापमान, टॉप-पी आदि यहीं)। ५. डिकोड चरण: टोकन जोड़ें, कैश अपडेट करें, रोक शर्त या अधिकतम टोकन तक दोहराएँ। ६. उपयोगकर्ता के लिए डिटोकनाइज़ करें।
प्रोडक्शन दर्द कहाँ दिखता है:
- विशाल सिस्टम प्रॉम्प्ट हर अनुरोध पर बड़ा प्रीफ़िल वसूलते हैं (जब तक प्रीफ़िक्स कैश न लगे)।
- खंड बजट के बिना रैग सस्ती चैट को लंबे-कॉन्टेक्स्ट काम में बदल देता है।
- ऊँची समकालिकता केवी मेमोरी गुणा करती है।
- आउटपुट टोकन सीमा लागत रोकती है, पर उपयोगकर्ता प्रीफ़िल से पहला-टोकन-समय और डिकोड बैंडविड्थ से टोकन/सेकंड महसूस करता है।
सिस्टम डिज़ाइन करते समय क्या याद रखें
- एम्बेडिंग अलग-अलग टोकनों को उस सदिश-स्थान में ले जाती है जहाँ स्टैक काम करता है।
- अटेंशन श्रृंखला में जानकारी का चयनात्मक मिश्रण है; कारण मास्क जनरेशन को संभव बनाते हैं।
- एनकोडर बनाम डिकोडर मुख्यतः मास्क + उद्देश्य है; अधिकांश चैट एलएलएम केवल-डिकोडर हैं।
- कॉन्टेक्स्ट विंडो साझा टोकन बजट और लगभग-वर्गाकार लागत केंद्र है, मुफ़्त भंडारण नहीं।
- केवी कैश संवादात्मक डिकोडिंग को संभव बनाता है, और इन्फरेंस वीरैम तथा बैचिंग रणनीति का मुख्य चालक है।
अगर एक ही सिस्टम वाक्य रखें: प्रीफ़िल कैश बनाता है, डिकोड बढ़ते कैश को पढ़ता है और वज़न स्ट्रीम करता है, और बिल दोनों चरणों में टोकनों का पीछा करता है।
उत्पाद दस्तावेज़ पढ़ने, जीपीयू आकार तय करने, और मॉडल टीम से ठोस बात करने के लिए इतना काफी है। २०१७ पेपर का बीजगणित फिर से गढ़ने का नाटक ज़रूरी नहीं।