LLM डेवलपमेंट प्रक्रिया भाग 8 - प्रशिक्षित किए जा सकने वाले self-attention की तकनीक

• GPT-शैली के decoder-only Transformer में प्रशिक्षित किए जा सकने वाला self-attention यह गणना करता है कि हर token को पहले आए इनपुट के किन token पर ध्यान देना चाहिए, और उसी से context vector बनता है
• इसका केंद्र scaled dot product attention है, जो input embedding को query, key, value space में भेजने वाले तीन trainable matrix Wq, Wk, Wv का उपयोग करता है
• input matrix X को Q=XWq, K=XWk, V=XWv में बदला जाता है, फिर Ω=QKᵀ को √c से भाग देकर row-wise softmax से attention weight A प्राप्त किया जाता है
• context vector C=AV नाम की एक matrix multiplication से बनता है, और पूरी गणना 5 matrix multiplication और एक transpose के साथ सभी token पर लागू की जा सकती है
• यह चरण input embedding के बीच सीधे dot product करने वाले toy example से आगे बढ़कर, PyTorch nn.Module और nn.Linear से लागू किए जा सकने वाले trainable attention तक पहुंचता है

---

LLM processing flow में self-attention की जगह

• GPT-शैली का decoder-only Transformer आधारित LLM अब तक आए token को देखकर अगला token predict करने वाली संरचना है
• processing flow में पहले string को token में तोड़ा जाता है, फिर हर token को token embedding में बदला जाता है, और उसके बाद position information दिखाने वाले positional embedding को जोड़कर input embedding बनाया जाता है
• self-attention हर input embedding के लिए यह दिखाने वाली attention score की सूची बनाता है कि उसे दूसरे token पर कितना ध्यान देना चाहिए
  • उदाहरण वाक्य "the fat cat sat on the mat" में "cat" को देखते समय "fat" महत्वपूर्ण हो सकता है
  • "mat" को देखते समय "fat" का महत्व अपेक्षाकृत कम हो सकता है
• attention score, softmax से गुजरकर कुल योग 1 वाले attention weight बन जाते हैं, और इन्हीं weight से input embedding का weighted sum लेकर context vector बनाया जाता है
• context vector को ऐसे vector की तरह देखा जाता है जो हर token के अर्थ को पूरे input के context में व्यक्त करता है

trainable self-attention का लक्ष्य

• पिछले चरण तक input embedding के बीच सीधे dot product निकालने वाला toy self-attention उपयोग किया गया था
• इस चरण का लक्ष्य ऐसा trainable attention mechanism बनाना है जो input vector से attention score तैयार कर सके
• Sebastian Raschka की Build a Large Language Model (from Scratch) की section 3.4 इसे scaled dot product attention के रूप में लागू करती है
• फोकस इस बात पर है कि यह संरचना क्यों प्रभावी है, उससे अधिक इस पर कि यह किन गणनाओं से काम करती है

Query, Key, Value matrix और space projection

• input sequence की लंबाई n, input embedding dimension d, और context vector dimension c मानी जाती है
• input embedding sequence को x1, x2, x3, ... xn के रूप में लिखा जाता है, और हर input embedding एक d-dimensional vector होता है
• तीन trainable weight matrix परिभाषित किए जाते हैं
  • query weights matrix: Wq
  • key weights matrix: Wk
  • value weights matrix: Wv
• हर matrix का आकार d×c होता है, और यह d-dimensional input vector को c-dimensional space में project करता है
• input vector xm को query space में भेजने की गणना qm=xmWq है
• key space और value space में भी इसी तरह input embedding को अलग-अलग c-dimensional space में project किया जाता है

matrix को projection की तरह देखने का तरीका

• matrix का उपयोग बिंदुओं को rotate करने जैसी geometric transformation के लिए किया जा सकता है
• square matrix उसी dimension के भीतर transformation करते हैं, जबकि non-square matrix vector को दूसरे dimensional space में भेज सकते हैं
• उदाहरण के लिए 3×2 matrix, 3-dimensional vector को 2-dimensional vector में बदल सकता है
• 3D graphics में 3D point को 2D screen point में बदलने वाला frustum matrix भी ऐसे projection का उदाहरण है
• self-attention input embedding को query, key, value नाम के तीन अलग projection space में भेजता है, और फिर projected vector पर गणना करता है
• ये projection matrix training के दौरान सीखे जाते हैं, इसलिए simple dot product attention में न होने वाली indirection यहां आती है

attention score की गणना

• किसी खास input xm के लिए, दूसरे input xp पर attention score को query projection और key projection के dot product से परिभाषित किया जाता है
• गणना इस प्रकार है
  • qm=xmWq
  • kp=xpWk
  • ωm,p=qm·kp
• सभी input के लिए इस गणना को loop से किया जा सकता है, लेकिन matrix multiplication से इसे एक साथ निकाला जा सकता है
• पूरे input embedding को matrix X मानें, तो X का आकार n×d है
• key matrix को एक बार में K=XWk से निकाला जाता है
  • परिणाम K का आकार n×c है
  • इसकी हर row संबंधित input embedding का key space में projected vector है
• query matrix भी इसी तरह Q=XWq से निकाला जाता है
• सभी query और सभी key के बीच dot product, QKᵀ से मिलता है
  • Q का आकार n×c है
  • Kᵀ का आकार c×n है
  • परिणाम Ω का आकार n×n है
• Ωm,p यह दिखाने वाला attention score है कि xm का context vector बनाते समय xp पर कितना ध्यान दिया जाएगा

scaling और softmax normalization

• attention score, पहले के उदाहरण की तरह softmax से गुजरकर कुल योग 1 वाले weight में बदले जाते हैं
• softmax बड़े मानों को और बड़ा तथा छोटे मानों को और छोटा करते हुए पूरी सूची का योग 1 बना देता है
• वास्तविक LLM में d और c हजारों तक हो सकते हैं, इसलिए केवल softmax का उपयोग करने पर gradient बहुत छोटा हो सकता है
• ऐसे में softmax “step function की तरह” काम कर सकता है
  • इसे ऐसी स्थिति के रूप में समझा जा सकता है जहां सबसे बड़ा मान हावी हो जाता है और बाकी मान बहुत छोटे रह जाते हैं
• इसे कम करने के लिए attention score को projection space dimension c के square root से भाग देकर फिर softmax लगाया जाता है
• matrix रूप इस प्रकार है
  • A=softmax(Ω/√c, axis=1)
• axis=1 PyTorch-शैली की notation है, जिसका अर्थ है कि softmax को row-wise लागू किया जाता है
• परिणाम A normalized attention score, यानी attention weight matrix है

context vector बनाना

• value space projection को V=XWv से निकाला जाता है
• A, n×n आकार की attention weight matrix है
  • Am,p वह attention weight है जो xm का context vector बनाते समय input p पर लगाया जाएगा
• V का आकार n×c है, और इसकी हर row input embedding का value space में projected vector है
• context vector matrix को C=AV से निकाला जाता है
  • परिणाम C का आकार n×c है
  • C की m-वीं row, input xm के लिए context vector है
• यह गणना हर token के लिए value vector को attention weight से गुणा करके जोड़ने का काम एक ही matrix multiplication से करती है

पूरी गणना का सारांश

• input matrix X token sequence के input embedding रखता है, और इसका आकार n×d है
• तीन trainable matrix से input को क्रमशः query, key, value space में project किया जाता है
  • Q=XWq
  • K=XWk
  • V=XWv
• query और key के dot product से attention score निकाले जाते हैं
  • Ω=QKᵀ
• score को scale करने के बाद row-wise softmax लागू करके attention weight बनाए जाते हैं
  • A=softmax(Ω/√c, axis=1)
• value projection और attention weight को गुणा करके context vector बनाया जाता है
  • C=AV
• पूरा self-attention mechanism 5 matrix multiplication और एक transpose से सभी input token के context vector बना सकता है

PyTorch implementation और अगला चरण

• किताब की section 3.4 ऊपर की गणना को PyTorch code में लागू करती है, और वही matrix operation करने वाला एक सरल nn.Module subclass बनाती है
• पहले version में तीन weight matrix के लिए सामान्य nn.Parameter object उपयोग किए जाते हैं
• दूसरे version में अधिक प्रभावी training के लिए nn.Linear का उपयोग किया जाता है
• इसके बाद दो विषय लिए जाएंगे
  • causal self-attention: किसी खास token को देखते समय उसके बाद आने वाले token पर ध्यान न देने का तरीका
  • multi-head attention: ऐसा विषय जिसे शुरुआत में जितना जटिल समझा गया था, उतना नहीं निकलेगा
• batch processing एक अलग विचार का विषय बना रहता है
  • एक single input sequence में भी attention score matrix का उपयोग होता है
  • कई input sequence को parallel process करने के लिए matrix से ऊंचे क्रम के tensor की जरूरत पड़ सकती है
• अगला लेख Writing an LLM from scratch, part 9 -- causal attention में जारी रहता है