सीखे बिना हाथ से बनाए गए Transformer से सरल sequence prediction

 (vgel.me)
2 पॉइंट द्वारा GN⁺ 2023-09-24 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • GPT-2 जैसे decoder-only transformer की weights को बिना training के सीधे डिज़ाइन करके उसे (aab)* पैटर्न predict करने वाला एक प्रयोग
  • "aabaabaabaab..." prediction में ठीक पिछले दो tokens देखने पड़ते हैं, इसलिए यह साधारण alternating pattern की तुलना में attention के काम करने के तरीके को बेहतर दिखाता है
  • मॉडल को N_CTX=5, N_VOCAB=2, N_EMBED=8 के छोटे आकार में बनाया गया है, और a=0, b=1 tokenization तथा one-hot embedding का उपयोग किया गया है
  • एक single attention head हाल के दो tokens पर 0.5-0.5 attention बाँटता है, और a=1, b=-1 encoding के cancellation का उपयोग करके अगला token निकालता है
  • अस्पष्ट न होने वाले context में इसने 100.0% (27/27) accuracy दिखाई, लेकिन 5-token context से एक prediction के लिए लगभग 4,000 FLOPs चाहिए, इसलिए हाथ से लिखे नियम की तुलना में यह बहुत कम efficient है

बिना training के weights हाथ से तय किया गया mini GPT-2

  • लक्ष्य यह समझना है कि transformer और attention के हर component वास्तव में क्या करते हैं, और उसे सहज रूप से देख पाना
  • मॉडल न training करता है और न pretrained weights का उपयोग करता है; इसे एक शाम में हर weight को हाथ से तय करके बनाया गया है
  • संरचना GPT-2 जैसे decoder-only transformer की है, और implementation को jaymody के picoGPT implementation के आधार पर सरल बनाया गया है
    • layer norm हटाया गया
    • multi-head attention की जगह single head का उपयोग
    • transformer block की mlp feed-forward layer हटाई गई

(aab)* sequence क्यों चुना गया

  • शुरुआत में "ababababab" जैसी sequence predict करने की कोशिश थी, लेकिन transformer shifted sequence predict करता है, इसलिए यह काम बहुत आसान हो जाता है
    • अगर a है तो b, नहीं तो a predict करना होता, इसलिए position embedding की जरूरत ही नहीं पड़ती
  • अंत में काम "aabaabaabaab...", यानी (aab)* sequence prediction पर तय हुआ
    • अगर पिछले दो tokens ab या ba हैं, तो अगला token a है
    • अगर पिछले दो tokens aa हैं, तो अगला token b है
    • bb को इस task की सीमा से बाहर माना गया है
  • tokenization दो symbols तक सीमित एक सरल तरीका है
    • a है 0
    • b है 1

मॉडल dimensions और calculation flow

  • चुने गए model parameters तीन हैं
    • N_CTX = 5: अधिकतम context length जिसे मॉडल एक बार में देखता है
    • N_VOCAB = 2: a, b दो tokens
    • N_EMBED = 8: embedding size, जिसमें token, position और computation space समाते हैं
  • असली task में सिर्फ पिछले दो tokens की जरूरत है, लेकिन N_CTX=5 रखने से ऐसे cases भी शामिल होते हैं जहाँ असंबंधित tokens को ignore करना पड़ता है
  • gpt function इस क्रम में काम करता है
    • wte[inputs] + wpe[range(len(inputs))] से token embedding और position embedding जोड़े जाते हैं
    • फिर यह एक transformer block से गुजरता है
    • अंत में x @ wte.T से vocabulary space के logits बनते हैं

position और token को one-hot के रूप में रखने वाली embeddings

  • wpe position embedding है, जिसमें शुरुआती 5 embedding dimensions को position one-hot के रूप में इस्तेमाल किया गया है
    • position 0 है [1, 0, 0, 0, 0]
    • position 4 है [0, 0, 0, 0, 1]
  • wte token embedding है, जिसमें अगले 2 dimensions को token one-hot के रूप में इस्तेमाल किया गया है
    • token a के लिए संबंधित token dimensions में [1, 0]
    • token b के लिए [0, 1]
  • 8वीं embedding position को शुरू में उपयोग नहीं किया जाता, और transformer block के अंदर scratch space की तरह इस्तेमाल किया जाता है
  • उदाहरण के लिए "aabaa" को 5 x 8 embedding matrix के रूप में दर्शाया जाता है, जहाँ हर row में position one-hot और token one-hot दोनों शामिल हैं

attention head हाल के दो tokens कैसे चुनता है

  • transformer block में एक attention head और attention result को फिर से embedding space में लौटाने वाली c_proj linear layer शामिल है
  • c_attn एक embed_size x (embed_size * 3) आकार की linear layer है, जो input embedding को qkv matrix में बदलती है और फिर उसे q, k, v में बाँटती है
  • k position embedding को अलग करके हर token की position information दिखाता है
  • q यह बताता है कि हर position किन positions को खोजना चाहती है, और q @ k.T के जरिए attention score matrix बनता है
  • softmax और causal mask के बाद attention matrix में ये गुण होते हैं
    • पहली row केवल पहले token पर 100% attention देती है
    • उसके बाद की rows पहुँच योग्य सबसे हाल के दो tokens पर 0.5-0.5 attention देती हैं
  • causal mask future token positions पर बहुत छोटा मान जोड़ता है, वास्तविक code में -1e10 जैसा, ताकि भविष्य के tokens न दिखें
    • यह हाथ से बना मॉडल भविष्य में झाँकने के लिए डिज़ाइन नहीं किया गया है, लेकिन GPT-2 जैसी संरचना बनाए रखने के लिए mask रखा गया है
  • np.sqrt(q.shape[-1]) से होने वाली scaling वास्तविक training में gradients सुधारने में मदद करती है, लेकिन इस hand-made मॉडल पर इसका असर नहीं पड़ता

v encoding और additive cancellation से बनी prediction

  • v token one-hot को a=1, b=-1 encoding में बदलता है
  • क्योंकि attention result हाल के दो tokens का 0.5-0.5 average लेता है, यह encoding नीचे का नियम निकालती है
    • a, b → 0.5 * 1 + 0.5 * (-1) = 0
    • b, a → 0.5 * (-1) + 0.5 * 1 = 0
    • a, a → 0.5 * 1 + 0.5 * 1 = 1
  • नतीजतन row की 7वीं position में यह मान बनता है
    • 0 होने पर a predict करना चाहिए
    • 1 होने पर b predict करना चाहिए
  • input "aabaa" में पहली row पर जानकारी कम होने से b prediction आ सकती है, लेकिन उसके बाद की predictions (aab)* नियम से मेल खाती हैं

prediction को फिर से vocabulary space में भेजना

  • c_proj attention result की 7वीं position के मान को token one-hot format में वापस बदलता है
  • यह सीधे [..., 1, 0, ...] या [..., 0, 1, ...] नहीं बनाता, बल्कि 1024 से scaled one-hot बनाता है
    • embedding[row, 5] = 1024 + (-1024) * prediction
    • embedding[row, 6] = 0 + 1024 * prediction
  • transformer block में residual connection है, इसलिए x = x + causal_self_attention(...) के रूप में मूल embedding वापस जुड़ती है
  • residual signal अनावश्यक रूप से बचा रहता है, इसलिए 1024 scale का उपयोग करके उसे दबा दिया जाता है
  • अंत में x @ wte.T निकालकर logits बनते हैं और softmax लागू होता है
    • "aabaa" context में अंतिम prediction row b की ओर इशारा करती है
    • training के समय सभी rows की predictions उपयोगी होती हैं, लेकिन inference में केवल आखिरी row चाहिए

generation result और accuracy

  • complete function आखिरी अधिकतम 5 tokens को मॉडल में डालता है और softmax result की आखिरी row से argmax लेकर अगला token चुनता है
  • उदाहरण generation results इस प्रकार हैं
    • complete("a") → a :: baabaabaab
    • complete("ba") → ba :: abaabaabaa
    • complete("abaab") → abaab :: aabaabaaba
  • सीमा के बाहर के input पर भी यह कभी-कभी repeating pattern में वापस लौट आता है
    • complete("ababa") → ababa :: abaabaabaa
    • complete("bbbbb") → bbbbb :: aabaabaaba
  • "aab" * 10 test में सिर्फ non-ambiguous contexts को evaluate करने पर accuracy 100.0% (27/27) है

4,000 FLOPs बनाम 8 instructions

  • पूरे 5-token context का उपयोग करने पर यह मॉडल एक token predict करने के लिए लगभग 4,000 floating point operations मांगता है
    • इसका अधिकांश हिस्सा attention calculation में जाता है
    • context window घटाकर, fused multiply-add, kv caching आदि से इसे कम किया जा सकता है
    • फिर भी एक token prediction के लिए सैकड़ों machine instructions की जरूरत पड़ती है
  • इसी (aab)* नियम को सीधे लिखी गई x64 assembly सिर्फ 8 instructions में अगला token निकाल लेती है
  • सवाल बचता है कि क्या natural language generation के लिए मौजूदा मॉडलों से 1000 गुना अधिक efficient language model train किया जा सकता है

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

1 टिप्पणियां

 
GN⁺ 2023-09-24
Hacker News रायें

  • इससे जुड़ा काम "Thinking Like Transformers" है
    यह RASP नाम की एक primitive programming language पेश करता है, जो उन operations से बनी है जिन्हें Transformer components से model किया जा सकता है, और दिखाता है कि histogram या sorting जैसे programs लिखे जा सकते हैं
    Sasha Rush और Gail Weiss की एक शानदार blog post भी है, और बाद की research ने दिखाया कि RASP-जैसे programs को training के बिना सीधे असली model weights में compile किया जा सकता है
    [1] https://arxiv.org/abs/2106.06981
    [2] https://srush.github.io/raspy/
    [3] https://arxiv.org/abs/2301.05062

    • मुझे RASP परिवार वाकई पसंद है
      अगर यह क्षेत्र आपको दिलचस्प लगता है, तो मेरा HandCrafted Transformers काम भी देखने लायक है, जिसमें मैंने Transformer model के weights खुद चुने हैं ताकि वह इंसानों द्वारा primary school में सीखे जाने वाले तरीके जैसा long addition कर सके
      [1] https://colab.research.google.com/github/newhouseb/handcraft...
    • ऐसे काम के लिए Haskell जैसी functional language अच्छी तरह फिट हो सकती है
      neural network से code की दिशा में जाना भी explainability के लिहाज से काफी दिलचस्प होगा

  • मुझे लगता था कि मैं Transformer को अच्छी तरह समझता हूँ, लेकिन कभी खुद implement नहीं किया था
    एक दिन जब खुद implement किया, तो वह standard PyTorch Transformer जितना अच्छा काम नहीं कर रहा था या train नहीं हो रहा था, और आखिर में समझ आया कि वजह dropout को नजरअंदाज करना था
    मैंने उसे number addition पर train किया था और किसी भी same pair को दो बार नहीं दिखाया था, इसलिए मुझे लगा था कि overfitting असंभव है, लेकिन dropout की भूमिका उम्मीद से कहीं ज्यादा बड़ी निकली
    सार यह है कि Transformer को बस खुद implement करके देखना अच्छा है, और जितना ज्यादा scratch से करेंगे उतना बेहतर
    जिन लोगों ने ऐसा किया, उन सभी ने कुछ न कुछ अप्रत्याशित सीखा; token-level training parallelization से लेकर backpropagation असल में कैसे काम करता है, हर व्यक्ति की समझ अलग जगह पर खुली

    • सोच रहा हूँ कि इस काम तक पहुँचने में मदद करने वाली कोई references होंगी क्या

  • Karpathy की सामग्री भी अच्छी है, लेकिन मेरे लिए Transformer आखिरकार इस video से समझ आया: https://youtu.be/kWLed8o5M2Y?si=SJT5_lCJ0hSR7Z_k

  • मैं भी काफी समय से इसी तरह सोचता रहा हूँ
    क्या model weights के लिए ऐसा intuitive interface बनाया जा सकता है जिसे domain experts हाथ से tune करके training को तेज कर सकें?
    उदाहरण के लिए, visual model में traffic cone detect करते समय "orange-ness" से जुड़े weights के समूह को बढ़ा देना
    तब "orange-ness" को ठीक से calibrate करने के लिए हजारों-लाखों और examples मांगने के बजाय इंसान इसे accelerate कर सकता है
    बेशक मुश्किल यह है कि यह interface अलग-अलग meanings वाले weight groups पर map होना चाहिए, लेकिन सोचता हूँ कि क्या कोई तकनीकी कारण है जिससे यह असंभव हो

    • "domain expert model के weights हाथ से adjust करता है" सुनने में deep learning से पहले की image recognition जैसी लगती है
      [1] https://www.youtube.com/watch?v=8SF_h3xF3cE&t=1358s
    • आप जिस वजह को खोज रहे हैं, उसे The Bitter Lesson कहा जाता है
      संक्षेप में, AI में इंसानी मदद जोड़ने वाले तरीके लगभग हमेशा ज्यादा compute power से चलाने की तुलना में कम cost-effective होते हैं
      जब तक कोई इंसान orange traffic cone detect करने के लिए weight layer को calibrate कर रहा होता है, GPU cluster AI को traffic cones, traffic lights, trees, दूसरी cars, और थोड़े अलग orange रंग के traffic cones तक detect करना सिखा चुका होता है
    • layers और weights की संख्या इतनी नहीं है कि इंसान उन्हें manually update कर सके, और अगर संभव भी हो तो weights बदलने के downstream effects manage करना बहुत कठिन है
      भले ही आप orange को बेहतर देखने के लिए picture को adjust करें, अगर साथ-साथ बाकी सभी colors की accuracy monitor नहीं कर सकते, तो अनजाने में किसी दूसरे color में समस्या पैदा कर सकते हैं
    • तकनीकी रूप से असंभव या बहुत कठिन होने की वजह यह है कि weights आम तौर पर interpret करना बहुत कठिन होते हैं
      ऐसा नहीं होता कि neurons का कोई खास cluster किसी खास concept से correspond करे; लगभग हर चीज थोड़ी-थोड़ी हर काम करती है
    • Transformer का attention mechanism इंसान द्वारा समझी जा सकने वाली semantics में आसानी से map होता नहीं लगता
      इसमें शामिल parameters बहुत ज्यादा हैं

  • Transformer paper बहुत technical था, इसलिए मैं हमेशा इसे थोड़ा-बहुत ही सही समझना चाहता था, लेकिन यह मुश्किल था
    इस लेख ने इसके काम करने के तरीके को समझने में सचमुच मदद की, और कम से कम examples तो बहुत स्पष्ट थे
    इसकी वजह से university में सीखे हुए matrices भी फिर याद आ गए

  • क्या यह Turing machine या regular expression parse करने वाली machine जैसी किसी तरह की abstract machine नहीं है?

    • थोड़ा सरल करके कहें तो, यह एक "machine" है जो input set को अगले output की probability set में map करती है
      पहले tokens की list define करते हैं, मान लें आसानी के लिए 24 अक्षर हैं
      यह machine token input sequence लेती है, deterministic matrix operations करती है, और फिर सभी tokens की probability list output करती है
      "learning" बस उन operations में इस्तेमाल होने वाली matrices के अंदर कुछ numbers set करने की प्रक्रिया है
      ध्यान देने लायक है कि final code में केवल एक if statement है, और वह भी result की accuracy evaluate करने के लिए है
      सारी "logic" matrix operations के results से आती है
    • ऐसी चीजों को आम तौर पर सोचे जाने वाले अर्थ में automata के रूप में समझना काफी मुश्किल है
      neural networks में लगभग सब कुछ थोड़ा धुंधला होता है, और if/else जैसी चीजें लगभग नहीं होतीं, हालांकि Transformer example की तरह values को 0 या -∞ से "mask" करने के cases होते हैं
      output भी लगभग हमेशा scores या probabilities का bundle होता है; अगर cat और dog photos अलग करने वाला model dog:0.95 cat:0.05 जैसा result देता है, तो हम कहते हैं कि उसने dog predict किया क्योंकि dog score ज्यादा है
      Transformer का core attention mechanism एक तरह के soft lookup operation पर आधारित है
      अगर system धुंधला न हो, तो वह sequence के हर token पर iterate करके देखेगा कि वह current token से relevant है या नहीं, और relevant होने पर कुछ action करेगा; लेकिन Transformer में relevance binary decision नहीं है
      इसके बजाय, sequence के सभी token pairs के बीच continuous relevance scores calculate किए जाते हैं, और उन scores का इस्तेमाल करके अगला action किया जाता है
      हालांकि कुछ चीजें binary-decision-based systems से सीधे generalize करना आसान नहीं होतीं
      उदाहरण के लिए, ऐसे relevance scores vocabulary tokens पर weighted average calculate करने के लिए weights की तरह इस्तेमाल होते हैं, और current position के लिए एक "average token" मिलता है
      इसे branching logic पर आधारित process के extension के रूप में आसानी से interpret करने का कोई तरीका नहीं दिखता
    • क्या यह ऐसा नहीं है जैसे linear algebra के ढेर को AllSpark छू गया हो?
    • सही
      यह paper देखना अच्छा रहेगा, जो समझाता है कि Linear Transformers असल में Fast Weight Programmers हैं: https://arxiv.org/abs/2102.11174
    • neural networks Turing machines हैं
      weights को सावधानी से set करें तो उनसे कोई भी computation करवाया जा सकता है
      बस अच्छा होता अगर approximation पर आधारित न होने वाला compiler होता

  • "शायद आपको खुद model बनाकर देखने का मन हो" वाली बात को curious learning exercise के अलावा किस काम में लगाना चाहते हैं, यह जानना चाहूंगा
    लगने लगा है कि complex machine learning models घर पर blog पढ़ने वाले व्यक्ति के लिए handle करना अव्यावहारिक है

    • nanoGPT में, Shakespeare पर model pretrain करने पर 3 मिनट में original material के लिए Lewis Carroll के Jabberwocky जैसी fidelity तक पहुंच जाता है
      यह बहुत सारे believable old English words बना देता है, English grammar की basics और plays का format वगैरह सीखता है
      इतने कम समय में उस level तक पहुंचना काफी हैरान करने वाला था
      local पर कई models को Shakespeare-from-Wish.com जैसी fidelity तक train करके देखना, यह judge करने में मदद कर सकता है कि आपने अच्छी architecture पाई है या अब उसे scale करने का समय है
    • article के पहले paragraph में उद्देश्य लिखा है
      इसमें कहा गया है कि author Transformer और attention को बेहतर समझना चाहता था, और The Illustrated Transformer पढ़ने के बाद भी attention के अलग-अलग pieces वास्तव में क्या करते हैं, यह intuitively समझ नहीं आया
      जैसे q और k में फर्क, और v तो और भी कहना ही क्या
    • यह बेहतरीन learning exercise है
      सिर्फ curiosity satisfy करने से आगे, यह understanding बनाने और उसे deepen करने में मदद करती है
    • शायद कोई सच में ऐसे projects hack करने का मजा ले सकता है? अजीब है, लेकिन संभव है

  • अच्छा होगा अगर title में neural network जैसा कोई expression शामिल हो सके
    यह दो circuits को electromagnetically couple करने वाली coils की bundle नहीं, बल्कि machine learning की "Transformer" architecture से संबंधित content है