Self-attention से आगे: छोटे language model अगला token कैसे predict करते हैं

 (shyam.blog)
2 पॉइंट द्वारा GN⁺ 2024-02-05 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • लगभग 1 करोड़ parameters वाले decoder-only Transformer को TinyShakespeare पर train करने के बाद, self-attention के बाद की गणना कैसे अगले token probability में बदलती है, इसे internal states और experiments के ज़रिए trace किया गया
  • मुख्य hypothesis यह है कि हर Transformer block prompt को training corpus की कुछ खास string sets से जोड़ता है, और उन strings के बाद वास्तव में आए tokens का frequency distribution block के अगले token prediction के काफ़ी करीब होता है
  • लागू की गई approximation procedure हर block के feed-forward network output से मिलती-जुलती training strings खोजती है, उनके बाद आए character distribution को जोड़ती है, फिर block-wise weighted sum से model output को reconstruct करती है
  • 20,000 length-10 prompts पर approximation output और वास्तविक Transformer output के बीच औसत Hellinger distance लगभग 0.17 था, जबकि उसी architecture को अलग seed से train किए गए alternate models और original model के बीच distance लगभग 0.11 ± 0.08 था
  • analysis इस व्याख्या को support करता है कि block transformation में feed-forward output का बड़ा योगदान है और attention prompt को सही training string class से map करता है, लेकिन यह छोटे models से आगे generalize होगा या नहीं, यह स्पष्ट नहीं है

प्रयोग में लिया गया model और मुख्य सवाल

  • लगभग 1 करोड़ parameters वाला Transformer Andrej Karpathy के Let’s build GPT: from scratch, in code, spelled out का अनुसरण करके implement और train किया गया
    • core language model code Karpathy का काम है, जबकि internal analysis और auxiliary code अलग contribution हैं
    • संबंधित code transformer-experiments में उपलब्ध है
  • model 6 blocks वाला decoder-only Transformer है
    • training data TinyShakespeare है, जिसमें Shakespeare के नाटकों की 40,000 lines शामिल हैं
    • RTX 4000 GPU पर लगभग 1 घंटे train करने के बाद इसने संरचनात्मक रूप से काफ़ी विश्वसनीय नकली Shakespeare text generate किया
  • tokens शब्द नहीं बल्कि characters हैं
    • vocabulary size 65 है, और model input prompt के बाद आने वाले character की probability distribution predict करता है
    • उदाहरण के लिए 'my most gr' के बाद यह a को 0.819, e को 0.081, i को 0.059 probability देता है
  • मुख्य सवाल self-attention खुद नहीं, बल्कि यह है कि attention के बाद का result अंतिम next-token probability में कैसे बदलता है

block structure और feed-forward network का महत्व

  • हर Transformer block में multi-head self-attention और feed-forward network शामिल हैं
    • PyTorch structure में block output का रूप x + self.sa(self.ln1(x)) के बाद x + self.ffwd(self.ln2(x)) जोड़ने जैसा है
    • intermediate variables के साथ देखें तो block output को x + sa_out + ffwd_out माना जा सकता है
  • जिस model का analysis किया गया, उसमें feed-forward network कुल trainable parameters का 65.71% हिस्सा रखता है
    • feed-forward parameters: 7,089,408
    • कुल trainable parameters: 10,788,929
  • feed-forward network output block input को output में बदलने का मुख्य कारक दिखता है
    • बाद के experiments में भी self-attention output की तुलना में feed-forward output का अंतिम probability distribution पर ज़्यादा असर दिखा

मिलते-जुलते feed-forward outputs से strings खोजना

  • approximation procedure prompt और training corpus strings की feed-forward output similarity का उपयोग करती है
    1. prompt को model में देकर हर block का feed-forward network output store किया जाता है
    2. हर block के लिए training corpus में वैसा ही feed-forward output देने वाली strings खोजी जाती हैं
    3. उन strings के बाद आए tokens की frequency distribution जोड़ी जाती है
    4. block-wise distributions का weighted sum लेकर normalize किया जाता है और probability distribution बनाई जाती है
  • demo prompt 'And only l' में block 1 के feed-forward output के साथ cosine similarity 0.95 से अधिक वाली length-10 strings की 94 matches मिलीं
    • मिली हुई strings जैसे hat only l, \nMy only l, I dearly l, ng Henry l, And only l प्रायः y l या ly l पर खत्म होती हैं
    • इन strings के बाद आए characters की normalized frequency distribution वास्तविक model के next-character prediction से बहुत मिलती थी
  • 'And only l' उदाहरण में approximation और वास्तविक model prediction काफ़ी पास थे
    • model: i 0.437, o 0.204, a 0.195, e 0.160
    • approximation: i 0.389, o 0.250, a 0.222, e 0.139
    • Hellinger distance 0.0711 था
  • केवल एक block से approximation हमेशा काम नहीं करती
    • prompt 'hing tremb' में सिर्फ block 1 इस्तेमाल करने पर model l 0.999 predict करता है, लेकिन approximation e 0.543, l 0.343 देती है, और Hellinger distance 0.6305 हो जाता है
    • सभी blocks को शामिल करने पर उसी example में approximation l 0.997 predict करती है और Hellinger distance 0.0233 तक घट जाता है

computation scale और manual tuning

  • efficiency के लिए analysis मुख्यतः length-10 strings पर किया गया
    • training corpus में 1,115,394 characters हैं, और unique length-10 substrings 858,923 हैं
    • feed-forward output 384-dimensional float32 vector है, और 6 blocks में हर एक से एक output निकलता है
  • 20,000 random length-10 strings को experiment prompts के रूप में चुना गया
    • हर prompt और 858,923 unique substrings के बीच block-wise cosine similarity पहले से calculate करके disk पर store की गई
    • क्योंकि meaningful matching cosine similarity 0.7 से नीचे नहीं दिखी, इसलिए 0.7 या उससे ऊपर वाले cases को ही pre-filter किया गया
  • block-wise similarity thresholds manual tuning से तय किए गए
    • block 0: 0.95
    • block 1: 0.94
    • block 2: 0.85
    • block 3: 0.76
    • block 4: 0.81
    • block 5: 0.89
  • block-wise frequency distributions को मिलाते समय manual weights भी इस्तेमाल किए गए
    • इस्तेमाल किए गए weights [0.01, 0.01, 0.1, 1.5, 6, 0.01] थे
    • deep learning approach से weights खोजने की कोशिश भी की गई, लेकिन manual tuning से बेहतर नतीजा नहीं मिला

20,000 prompts पर evaluation

  • पूरे 20,000 prompts पर approximation distribution और model output distribution के बीच Hellinger distance calculate किया गया
    • औसत: 0.1677
    • standard deviation: 0.1215
    • न्यूनतम: 0.0013
    • अधिकतम: 0.9994
  • Hellinger distance probability distributions के overlap को मापता है; 0 का मतलब समान, 1 का मतलब कोई overlap नहीं
  • approximation quality की तुलना के लिए वही architecture अलग random seed के साथ 3 बार और train किया गया
    • original model seed: 1337, estimated training loss 0.9334, validation loss 1.5063
    • Alternate 1 seed: 1442, training loss 0.9293, validation loss 1.5038
    • Alternate 2 seed: 88, training loss 0.9294, validation loss 1.4991
    • Alternate 3 seed: 99999, training loss 0.9339, validation loss 1.4941
  • original model और alternate models के बीच औसत Hellinger distance लगभग 0.11 ± 0.08 था
    • Original vs Alternate 1: 0.1064 ± 0.0823
    • Original vs Alternate 2: 0.1057 ± 0.0817
    • Original vs Alternate 3: 0.1053 ± 0.0828
  • approximation और model के बीच औसत distance 0.17, alternate models के 0.11 से ज़्यादा है, लेकिन standard deviation की range के भीतर है, इसलिए इसे approximation के काफ़ी अच्छा होने का आधार माना गया

Transformer के internal behavior की व्याख्या

  • model को embeddings के बाद कई चरणों वाली spatial transformation की तरह देखा जा सकता है
    • 6 Transformer blocks, 384-dimensional embedding space के भीतर input embedding को output embedding में transform करते हैं
    • अंतिम LayerNorm और linear layer embedding space को 65-dimensional logit space में बदलते हैं, और softmax अगली token probability बनाता है
  • block के अंदर transformation को vector addition के रूप में देखा जा सकता है
    • block output, input x, self-attention output sa_out, और feed-forward output ffwd_out का योग है
    • analysis में देखा गया कि feed-forward output vectors का norm आम तौर पर self-attention output से बड़ा था, और block-दर-block दोनों outputs प्रायः समान दिशा में इशारा करते थे
  • सिर्फ feed-forward outputs जोड़ने पर भी अंतिम output vector की दिशा काफ़ी हद तक मिलती-जुलती रहती है
    • केवल feed-forward वाला output norm में छोटा होता है, लेकिन दिशा मूल output के काफ़ी करीब होती है
    • अंतिम LayerNorm की वजह से norm का अंतर अंतिम linear layer के input में बहुत महत्वपूर्ण नहीं रहता
  • इसका मतलब यह नहीं कि self-attention computation हटाई जा सकती है
    • feed-forward network ffwd_out = self.ffwd(self.ln2(x + sa_out)) के रूप में self-attention output को input में शामिल करता है, इसलिए self-attention हटाने पर feed-forward output खुद बदल जाएगा

token subspace hypothesis

  • कुछ embeddings model को किसी खास token को लगभग निश्चित रूप से predict करने पर मजबूर कर सकती हैं
    • उदाहरण के लिए अंतिम block के बाद LayerNorm और linear layer में जाने वाली embedding को इस तरह train किया जा सकता है कि token a की probability लगभग 1 हो जाए
    • Transformer weights को fixed रखा जाता है और केवल embedding tensor optimize किया जाता है
  • हर token के लिए सिर्फ एक embedding नहीं, बल्कि कई embeddings मौजूद होती हैं
    • इसे हर token से जुड़े एक जटिल nonlinear embedding subspace के रूप में व्याख्यायित किया गया
    • हर token के लिए हज़ारों unique embeddings आसानी से train की जा सकीं
  • इस subspace को ठीक-ठीक गणितीय रूप में नहीं निकाला गया, लेकिन अंतिम चरण में linear approximation अच्छी तरह काम करती है
    • हर token के लिए सीखी गई embeddings को stack करके SVD किया गया
    • पहला right singular vector उस token subspace के 1-dimensional linear approximation की तरह अच्छा काम करता है
  • कई tokens के subspace approximation vectors को linear combination में मिलाकर ऐसी embedding बनाई जा सकती है जो probability को कई tokens में बाँट दे
    • a और b के approximation vectors को जोड़ने पर दोनों tokens पर probability बंटी हुई distribution मिलती है
    • हालांकि approximation error, subspace vectors की non-orthogonality, और token-wise logit magnitude के फर्क की वजह से यह पूरी तरह 50:50 distribution नहीं बनती

feed-forward output और token subspace का correspondence

  • feed-forward output को इस तरह समझा गया कि वह block output को किसी खास token subspace की दिशा में adjust करता है
    • वे tokens वही हैं जिन्हें approximation procedure predict करती है, यानी वे tokens जो ऐसी training strings के बाद आए जिनसे मिलते-जुलते feed-forward outputs बने
  • उदाहरण med me Aut में केवल अंतिम block देखें तो approximation o को सबसे संभावित अगला token और h को उसके बाद predict करती है
    • उसी feed-forward output vector को token subspace approximations पर project करने पर सबसे मिलते-जुलते tokens भी o, h, i, u, y क्रम में मिले
  • उदाहरण if and thy में भी ऐसा ही correspondence दिखता है
    • approximation space, s, newline को मुख्य predicted tokens मानती है
    • feed-forward output के साथ सबसे aligned subspaces भी space, s, newline के क्रम के करीब थे
  • पूरे 20,000 prompts पर एक arbitrary criterion बनाकर aggregate किया गया
    • criterion यह था: “क्या approximation prediction में 90% probability mass रखने वाले tokens के subspaces, feed-forward output के साथ cosine similarity ranking के ऊपरी आधे हिस्से में आते हैं?”
    • अंतिम block के लिए 16,357 cases, यानी 81.78%, इस criterion पर खरे उतरे

block-wise aggregate results और chance से तुलना

  • हर block position पर सीखे गए subspace approximations का उपयोग करने पर criterion satisfaction rate पीछे के blocks में ज़्यादा थी
    • block 6: 16,357, 81.78%
    • block 5: 10,142, 50.71%
    • block 4: 7,760, 38.80%
  • अंतिम चरण के subspace approximations को सभी blocks पर लागू करने से और बेहतर results मिले
    • block 6: 81.78%
    • block 5: 68.26%
    • block 4: 58.15%
    • block 3: 57.34%
    • block 2: 52.02%
    • block 1: 49.71%
  • यह भी simulate किया गया कि random cosine similarity के कारण यह criterion संयोग से कितनी बार पूरा हो सकता है
    • block 6: 20.76% ± 0.25%
    • block 5: 20.55% ± 0.26%
    • block 4: 18.37% ± 0.24%
    • block 3: 18.20% ± 0.24%
    • block 2: 17.04% ± 0.23%
    • block 1: 16.31% ± 0.23%
  • results chance से काफ़ी ऊपर हैं, लेकिन measurement noise और subspace approximation की सीमाओं के कारण इसे निर्णायक प्रमाण कहना मुश्किल है

self-attention की भूमिका

  • इस व्याख्या में अच्छी prediction इस बात पर निर्भर करती है कि prompt को training corpus की सही string class से map किया जाए
  • यह mapping करने वाली मुख्य धुरी self-attention है
    • attention layer prompt tokens के बीच के patterns की पहचान करती है
    • patterns अंत के y l जैसे simple string patterns हो सकते हैं, या किसी खास position पर vowel या uppercase जैसे अधिक सामान्य token types भी हो सकते हैं
  • attention heads के learned weights तय करते हैं कि वे किन patterns पर react करेंगे
    • attention head output जब feed-forward network से गुजरता है, तो वह embedding space में ऐसा representation बन जाता है जिसमें मिलती-जुलती training strings के बाद आने वाले token distribution की जानकारी रहती है
  • analyzed model में 6 blocks और हर block में 6 attention heads हैं, इसलिए एक prompt को कई latent patterns के संदर्भ में evaluate किया जा सकता है

निष्कर्ष और सीमाएँ

  • approximation procedure और वास्तविक Transformer output के समान होने के प्रमाण मज़बूत हैं
  • approximation procedure का वास्तविक Transformer की internal computation से correspond करना उतना स्पष्ट नहीं है, लेकिन यह कम-से-कम आंशिक रूप से सही होने की संभावना दिखाता है
  • एक छोटे Transformer से मिले नतीजे बड़े models या दूसरे datasets पर generalize होंगे या नहीं, यह अज्ञात है
  • यह project model के अंदर सवाल पूछने और experiments design करने की प्रक्रिया है, और language model के “जादू” को किसी एक सरल mechanism में घटाने के बजाय उसकी जटिलता को और स्पष्ट दिखाता है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2024-02-05
Hacker News की राय

  • मूल पोस्ट के कुछ विषय उन लोगों के लिए बहुत चौंकाने वाले नहीं होने चाहिए जिन्होंने https://people.math.harvard.edu/~ctm/home/text/others/shanno... पढ़ा है
    अगर आप अपने क्षेत्र का बुनियादी साहित्य नहीं पढ़ते, तो पहले से व्यवस्थित काम के स्वाभाविक नतीजे के रूप में पैदा होने वाली घटनाएँ भी ऐसी रहस्यमयी लगने लगती हैं जिनकी व्याख्या नहीं हो सकती
    फिर भी, प्रयोग पहली नज़र में काफी thorough लगते हैं, और इसमें लगी विस्तृत मेहनत की मैं सराहना करता हूँ
    मौजूदा theory सीखने और शुरुआत से खुद फिर से derive करने के बीच एक कठिन trade-off है। पारंपरिक आधार न हो तो नई खोज संभव हो सकती है, लेकिन आधार हो तो किसी खास phenomenon को और गहराई से समझा जा सकता है
    यहाँ टिप्पणियों में कई लोग हैरान दिख रहे हैं कि data दिए जाने पर sequence की log likelihood को maximize करने वाला model inference के समय जादुई रूप से उस behavior से बाहर नहीं निकल जाता। यह density estimation model है; क्या आप चाहते हैं कि यह हवा से Shakespeare सुनाने लगे?
    बुनियादी बातों पर लौटें तो ऐसे प्रयोग बहुत बेहतर समझ में आते हैं। इसे, और तथाकथित emergent phenomena को, समझाने वाला बहुत स्पष्ट mathematical आधार पहले से मौजूद है
    और खास तौर पर, इसके कई स्तर हैं, और Shannon का ergodic systems को handle करना एक अच्छा शुरुआती बिंदु है। यहाँ कुछ हिस्से थोड़े अलग पड़ते हैं, लेकिन पूरी dynamics को समझने के लिए यह काफी करीब का correspondence लगता है

    • बहुत तेज़ information theory researchers कुछ सालों से neural networks को information theory perspective से देख रहे हैं और उन्होंने मशहूर papers भी लिखे हैं, लेकिन उससे neural networks के बहुत बड़े हिस्से की व्याख्या नहीं हो पाई। फिर भी यह दिलचस्प था
      समझदार लोगों का यह कहना असामान्य नहीं है कि “यह mathematical structure उस idea जैसा है, बस कुछ structures और जोड़ या घटा दें तो सब समझाया जा सकता है।” लेकिन असल में हमें बहुत कुछ नहीं पता
      मैंने इस क्षेत्र के theorists को theory लेकर आकर कुछ नया बनाते या उपयोगी predictions देते नहीं देखा। आम तौर पर लोग इधर-उधर चीज़ें try करते हैं, अगर काम कर जाए तो बाद में क्यों काम किया इसका plausible explanation जोड़ देते हैं, और अगर न चले तो उसे दबा देते हैं
      हाल में transformer को kernel smoothing के रूप में देखने वाला एक लेख भी आया था: https://arxiv.org/abs/1908.11775
    • आपकी बात समझता हूँ, लेकिन अलग-अलग depth वाले alternative paths के ज़रिए convergence होना अपने-आप में भी एक signal है
      बार-बार rediscovery होना ज़रूरी नहीं कि waste ही हो; यह कई पहुँचने के रास्तों वाली किसी गहरी सच्चाई की पुष्टि और validation की प्रक्रिया भी हो सकती है
    • पास के एक दूसरे thread में चर्चा हो रही है कि neural networks का training data से एक तय error margin के भीतर fit होना copyright के लिए क्या मायने रखता है
      information theory की कई textbooks पहले ही ऐसे networks की content-addressable प्रकृति की ओर इशारा करती हैं[1], और इसी वजह से इन्हें compression जैसे applications में भी इस्तेमाल किया जाता है[2][3]
      इसलिए जब NYT ने OpenAI model को अपने articles के कुछ paragraphs prompt में दिए और वे लगभग हूबहू reproduce हो गए, तो यह चौंकाने वाली बात नहीं है
      [1] https://www.inference.org.uk/itprnn/book.pdf
      [2] https://bellard.org/nncp/
      [3] https://pub.towardsai.net/stable-diffusion-based-image-compr...
    • तो फिर सवाल उठता है कि Shannon GPT क्यों नहीं बना पाए

  • जब Google ने बताया था कि अगर ChatGPT से वही शब्द बार-बार दोहराने को कहा जाए तो उससे training data ज्यों का त्यों उगलवाया जा सकता है[0][1], उसे देखकर मेरे दिमाग में बिल्कुल यही idea आया था। खुशी है कि किसी ने इसे सच में implement कर दिया
    यहाँ दो और सवाल उठते हैं

    1. क्या यह “AI, AI को पकड़ो” approach, gradient descent backpropagation से training data को model में compress करके उसे dedicated AI co-processor पर चलाने की तुलना में energy-efficient होगा?
    2. क्या यह result OpenAI और Stability AI के खिलाफ चल रहे मुकदमों में सबूत बन सकता है?
      [0] पहले यह संभव था। OpenAI अब context window को एक ही शब्द से भरने पर generation block कर देता है
      [1] https://arxiv.org/abs/2311.17035
    • यह approach मूल model चलाने से ज्यादा efficient नहीं हो सकती। क्योंकि मूल model चलाकर activation values लेनी पड़ती हैं, फिर corpus में उन activation values जैसी strings खोजनी पड़ती हैं और next token statistics calculate करने पड़ते हैं
      इसमें छोड़े जाने वाले steps ज्यादा नहीं हैं, उल्टा काफी extra काम जुड़ जाता है
      model training corpus और activation-value string search के लिए corpus को पूरी तरह अलग कर दें, तब भी लगभग वही result आएगा लगता है। मुश्किल हिस्सा तो शुरुआत में यही है कि ऐसी strings के लिए similar activation values बनें जिनकी next token statistics similar हों
      layer-wise weights [0.01, 0.01, 0.1, 1.5, 6, 0.01] में सबसे महत्वपूर्ण second-last layer है, और उस समय input पहले ही काफी transform हो चुका होता है। इसलिए इससे यह उम्मीद नहीं करनी चाहिए कि transformer को training data पर simple grep से replace किया जा सकता है
      second-last layer का weight final layer से बहुत ज्यादा होने की वजह शायद induction heads हैं। https://transformer-circuits.pub/2021/framework/index.html की तरह यह input में repeated strings को copy करने की capability implement करता हो सकता है, जहाँ second-last layer तय करती है कि क्या खोजना है और final layer copy perform करती है
    • अगर बात इस idea की है कि LLM output training data पर आधारित next token probabilities के अनुसार चलता है, तो यह तो well-known basic fact है, इसलिए यह result सबूत बनने की संभावना कम लगती है
      इस लेख का योगदान, जैसा लेखक कहता है, transformer खुद पर focused “इसे implement कैसे किया गया?” वाले लेखों से अलग, सीधे GPT बनाने वाले technical readers को यह बात दिखाने में है
    • block होने से पहले जब मैंने इसे try किया था, तो इसने ऐसी चीजें hallucinate कीं जो असली training data जैसी दिखती थीं
      ध्यान से देखने पर वे मौजूद ही नहीं थीं और आगे-पीछे भी मेल नहीं खाती थीं—जैसे GitHub README, खाली-content वाले guide brochures, random conversations
    • linked arXiv paper में इसे attack, ethics, और responsible disclosure के रूप में treat किया गया, यह दिलचस्प लगा
      लेकिन ऐसे models train करने के लिए पूरा internet scrape करने को कभी attack नहीं कहा जाता
    • अगर किसी work पर copyright है, तो उस work की zip file पर भी अधिकार होना स्वाभाविक है
      तो फिर उस work के अंदर की character probability distribution पर अधिकार मानने से रोकने वाली बात क्या है?

  • Andrej Karpathy का NanoGPT पता चलते ही मैंने उसे रूसी version War and Peace पर train करके देखा, और यह दिलचस्प था कि सिर्फ 3MB model होते हुए भी उसने Russian grammar को काफी हद तक समझ लिया
    रूसी में जटिल synthetic और inflectional structure है। उदाहरण के लिए preposition “na”(“upon”) के बाद accusative noun आना चाहिए, जो animate masculine nouns में -a, inanimate nouns में no ending, “soft consonant” पर खत्म होने वाले nouns में -ia, feminine nouns में -u आदि के रूप में दिखता है
    साथ ही “use” क्रिया, जब उसके बाद tool के रूप में इस्तेमाल हो रहा noun आता है, तो instrumental case मांगती है
    यह perfect नहीं था और गलतियाँ भी थीं, लेकिन NanoGPT ने सिर्फ 3 मिनट की training में कुछ खास complex rules infer कर लिए, यह interesting था। generated exact example sentences को मैंने original text में खोजा, लेकिन बिल्कुल matching कुछ नहीं मिला
    हालांकि grammar कुछ हद तक समझने के बावजूद, meaning के स्तर पर यह पूरी तरह बकवास था

    • ending changes training text में सबसे common tokens में होंगी, इसलिए यह बहुत surprising नहीं है

  • इसी system को दिखाने वाली एक अच्छी 3D visualization थी, और साथ पढ़ने पर काफी असरदार लगती है
    LLM Visualization (https://bbycroft.net/llm)
    https://news.ycombinator.com/item?id=38505211

    • इस visualization में लगी मेहनत के लिए आभार, लेकिन 9 साल neural networks के साथ काम करने के अनुभव से कहूँ तो यह मददगार से कहीं ज्यादा confusing लगी
      शायद इसलिए कि इसमें सारी चीजें एक साथ दिखाने की कोशिश की गई, और उन्हें abstract concepts पर defer नहीं किया गया—हालांकि मुझे पूरा यकीन नहीं

  • अच्छा project है, लेकिन analysis का target model size और training data दोनों के लिहाज से असल में toy model है
    इसलिए इस model को शायद किसी simpler model, शायद n-gram language model से approximate किया जा सकता है, लेकिन यह मानना मुश्किल है कि यह बड़े language models के काम करने के तरीके को represent करता है

    • शायद यह सही है। अगर और छोटा model बनाया जाए तो उसके काम करने के तरीके के बारे में कहीं ज्यादा simple explanation भी बनाई जा सकती है

  • मुझे जिज्ञासा है कि क्या लेखक यह दावा कर रहे हैं कि LLM एक Markov chain टेक्स्ट generator है
    यानी क्या इसका मतलब है कि generate होने वाले अगले token का probability distribution, training data में मौजूद उस token sequence की probability के बराबर है?
    अगर ऐसा है, तो क्या मूल training data से “सिर्फ” Markov chain बना देने पर LLM जैसी performance मिल सकती है?

    • LLM इस अर्थ में Markov chain है
      state context length जितना token vector है, और model transition matrix को describe करता है। दिए गए context length size के token vector के लिए यह अगले context length size के token vector की probability देता है
    • नहीं। LLM उसी text को बस copy नहीं करता, बल्कि self-attention से text को “classify” करने के बाद एक simple Markov chain apply करने जैसा है
      मुश्किल हिस्सा यह classification है कि कौन-सा training data text prompt text से “similar” है
      blog post के उदाहरण के हिसाब से यह ऐसा है
      Original string: 'And only l'
      Similar strings: 'hat only l' 's sickly l' ' as\nthey l' 'r kingly l'
    • लेख में लिखा है कि “transformer जो काम करता है, ऐसा suggest किया जाता है, उसे imperative code में implement किया गया, और transformer से बहुत मिलते-जुलते outputs बनाए”
      इसका मतलब है कि transformer को bypass करके वही परिणाम पाने का कोई तरीका हो सकता है। उत्सुकता है कि क्या यह ज्यादा efficient होगा
      उदाहरण के लिए, एक base model दिए जाने पर कोई और चीज train करके उसे कहीं ज्यादा छोटे device पर run करना संभव हो सकता है

  • यह समझना काफी मुश्किल है कि लेखक ने ठीक-ठीक क्या दिखाने का दावा किया है
    “Interpretation: Why Does the Approximation Work?” section मैंने कई बार पढ़ा, लेकिन यह transformer steps की mechanical explanation जैसा लगा। core claim क्या है, समझ नहीं आया

  • मुझे जिज्ञासा है कि क्या attention और FF displacement का आम तौर पर एक ही direction की ओर इशारा करना कोई known phenomenon है
    layers के पार उनका एक ही latent space में होना ही थोड़ा चौंकाने वाला है। क्या FF network arbitrary rotation नहीं कर सकता? लगता है मैंने कुछ गलत समझा है

    • यह बहुत high-dimensional vectors को 2D में represent किया गया है
      कुछ न कुछ छूटना ही है, और high-dimensional space में arbitrary rotation को सही-सही दिखाना भी उन्हीं छूटने वाली चीजों में से एक है
    • attention addition को scaling से बदलकर check करना अच्छा होगा