क्या LLM सिर्फ़ एक उदाहरण से सीख सकता है?

 (fast.ai)
2 पॉइंट द्वारा GN⁺ 2023-09-07 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • fast.ai ने Kaggle LLM Science Exam मॉडल को fine-tune करते समय ऐसा loss curve देखा, मानो LLM डेटासेट के उदाहरणों को एक बार देखने के बाद याद कर लेता हो
  • सामान्य neural network अक्सर कई epoch में धीरे-धीरे सीखते हैं, लेकिन इस प्रयोग में epoch boundary पर training loss सीढ़ियों की तरह अचानक गिरा, जो पिछले अनुभव से अलग था
  • Hugging Face Trainer, LoRA, या full fine-tuning—किसी भी सेटअप में मिलते-जुलते पैटर्न दिखे, इसलिए इसे सिर्फ़ library bug मानना मुश्किल हो गया
  • cyclical learning rate और 1cycle प्रयोगों में training loss, validation loss, और MAP@3 के बदलाव कुल मिलाकर memorization hypothesis से मेल खाते थे, और validation loss का बिगड़ना तुरंत accuracy गिरने के बराबर नहीं था
  • अगर pre-trained LLM बहुत तेज़ी से सीखते हैं, तो catastrophic forgetting, data augmentation, data mixing, और dropout जैसी fine-tuning strategies की फिर से जाँच करनी होगी

सामान्य neural network training से अलग दिखा loss curve

  • neural network classifier input और सही label को बार-बार देखकर output probability को adjust करता है
    • पूरे training data पर एक बार गुजरने की प्रक्रिया को epoch कहते हैं
    • loss यह दिखाता है कि model कितना गलत है, और जो prediction गलत होने के साथ बहुत confident भी हो, उस पर ज़्यादा penalty लगती है
  • आम तौर पर training की शुरुआत में training loss तेज़ी से घटता है और फिर धीरे-धीरे इसकी रफ़्तार कम हो जाती है, जबकि validation loss और धीमे सुधरता है
    • सिर्फ़ loss graph देखकर epoch की शुरुआत और अंत साफ़-साफ़ पहचानना आम तौर पर आसान नहीं होता
    • अनुभवजन्य रूप से यह सीमा रही है कि neural network को किसी खास image को ठीक से सीखने के लिए कई epoch चाहिए होते हैं
  • fast.ai ने Kaggle LLM Science Exam में विज्ञान के multiple-choice सवाल हल करने वाला model train करते समय अलग पैटर्न देखा
    • Radek Osmulski के बनाए बड़े question dataset पर 3 epoch training की गई
    • हर epoch के अंत में training loss में अचानक सीढ़ीनुमा गिरावट दिखाई दी

bug के शक से memorization hypothesis तक

  • शुरुआत में training process में bug होने का शक हुआ
    • उदाहरण के लिए, अगर validation set evaluate करते समय भी model सीखता रहे, तो validation के तुरंत बाद model अचानक बेहतर दिख सकता है
    • इसलिए पहले इस्तेमाल हो रहे Hugging Face Trainer में समस्या की संभावना देखी गई
  • Alignment Lab AI Discord के open source developers ने भी बताया कि उन्होंने ऐसे loss curve पहले देखे हैं
    • शुरुआती जवाब देने वाले सभी लोग Trainer इस्तेमाल कर रहे थे, इसलिए library bug वाली परिकल्पना काफ़ी संभव लगी
    • बाद में custom training loop में भी वही curve दिखने के उदाहरण साझा किए गए
  • यह भी जाँचा गया कि कहीं यह सिर्फ़ LoRA का अजीब behavior तो नहीं, लेकिन full fine-tuning में भी वही पैटर्न दिखा
    • LLM fine-tuning community में ऐसा loss curve लगभग आम बात निकला

Kaggle प्रयोग में दिखा तेज़ memorization pattern

  • open source साथियों की व्याख्या यह थी कि loss curve असल में overfitting दिखा रहा है
    • यानी model input को एक-दो बार देखकर ही पहचानने लायक सीख रहा था, जो शुरू में असंभव-सा लगा
    • पहले graph में loss पहले epoch के बाद 0.8 से 0.5 तक, और दूसरे epoch के बाद 0.5 से 0.2 से नीचे गिर गया
    • दूसरे और तीसरे epoch के बीच में लगभग कोई नई learning होती नहीं दिखी
  • अगर यह व्याख्या सही है, तो model ने हर row को सिर्फ़ 3 बार देखकर training set लगभग याद कर लिया
    • हर सवाल में model को मिलने वाला signal सिर्फ़ सही label और अपनी चुनी हुई prediction की तुलना से आता है
    • फिर भी training loss काफ़ी घट गया

cyclical learning rate से देखे गए loss के बदलाव

  • Kaggle model को 2 epoch तक train करते समय Leslie Smith के 2015 paper Cyclical Learning Rates for Training Neural Networks पर आधारित cyclical learning rate schedule इस्तेमाल किया गया
  • पहले epoch का curve सामान्य training pattern जैसा था
    • शुरुआती 10% हिस्से में learning rate warm-up किया गया
    • उसके बाद cosine schedule के अनुसार learning rate घटाया गया
    • learning rate पर्याप्त बढ़ने के बाद training loss और validation loss तेज़ी से घटे, फिर उनकी गिरावट धीमी हो गई
  • दूसरे epoch में dataset को दोबारा shuffle नहीं किया गया, इसलिए शुरुआती batch फिर से कम learning rate पर सामने आए
    • ये batch पहले epoch में भी सिर्फ़ कम learning rate पर ही देखे गए थे, इसलिए model ने इन्हें ज़्यादा नहीं सीखा था
    • पहले 10% के अंत तक, पहले epoch में high learning rate पर देखे गए batch फिर सामने आए और training loss अचानक गिर गया
  • इसी हिस्से में validation loss खराब हुआ
    • इसे बेहतर generalization नहीं, बल्कि training data को याद कर लेने और सही उत्तरों पर बहुत ज़्यादा confident हो जाने की स्थिति के रूप में देखा जा सकता है
    • क्योंकि loss function बहुत confident गलत उत्तरों पर ज़्यादा penalty देता है, इसलिए validation loss बिगड़ गया
  • curve के बाद के हिस्से में training loss फिर खराब होने लगा
    • सामान्य learning rate पर training loss का बिगड़ना आम बात नहीं है
    • memorization hypothesis के अनुसार, कम learning rate पर देखे गए batch model प्रभावी रूप से याद नहीं कर पाया, जबकि ठीक पहले के batch पर बनी ज़्यादा confidence की स्थिति बनी रही
    • बाद में model अधिक उचित confidence level पर वापस adjust हुआ, जिससे validation loss फिर घटा

1cycle प्रयोग और evaluation metric का फर्क

  • अगले प्रयोग में 3 epoch तक 1cycle training का उपयोग किया गया
    • training की शुरुआत वाले batch के 10% हिस्से में learning rate सिर्फ़ एक बार warm-up किया गया
    • बाकी batch पर cosine schedule के साथ learning rate घटाया गया
    • पिछले प्रयोग की तरह हर epoch में अलग से warm-up और decay नहीं दोहराया गया
    • learning speed धीमी करने के लिए LoRA rank बढ़ाया गया
  • परिणामस्वरूप curve पहले की व्याख्या से कुल मिलाकर मेल खाता था, लेकिन validation loss में बढ़ोतरी epoch 2 की बजाय epoch 3 में दिखी
    • पिछले प्रयोग में दूसरे epoch पर training loss लगभग 0.2 तक गिर गया था, जिससे बहुत confident prediction संभव हो गए थे
    • 1cycle प्रयोग में वही confidence level तीसरे epoch में जाकर मिला, और validation loss की बढ़ोतरी भी तब दिखी
  • validation loss का बिगड़ना ज़रूरी नहीं कि वास्तविक overfitting ही हो
    • Kaggle leaderboard metric top-3 multiple-choice prediction की rank-based accuracy Mean Average Precision @ 3 है
    • 1cycle training के batch-wise validation MAP@3 में आख़िरी epoch के दौरान validation loss बिगड़ने के बावजूद सुधार जारी रहा
  • अतिरिक्त logs और reproducible notebook Johno की report में देखी जा सकती है

single-example learning संभव क्यों हो सकती है

  • ऐसा कोई बुनियादी नियम नहीं है कि neural network single example से input पहचान ही नहीं सकता
    • researchers और practitioners ने अनुभव के आधार पर माना था कि neural network को बहुत सारे examples चाहिए होते हैं
    • अगर stochastic gradient descent (SGD) जिस loss surface को खोजता है वह बहुत ऊबड़-खाबड़ हो, तो एक ही बार में बड़ा कदम लेना कठिन होता है
  • loss surface को अधिक smooth बनाने वाले कुछ कारक पहले से जाने जाते हैं
  • pre-trained LLM में minimum loss के पास बहुत smooth loss surface हो सकता है
    • open source community की कई fine-tuning गतिविधियाँ शायद ऐसे ही क्षेत्र में हो रही हैं
    • यह 2018 के ULMFiT paper की मूल धारणा से जुड़ता है
  • ULMFiT का मूल विचार यह था कि language modeling में अच्छा model अपने भीतर समृद्ध abstractions और capability layers बनाता है
    • ऐसी layers को कम fine-tuning के साथ दूसरे tasks पर लागू किया जा सकता है
    • आज के LLM, ULMFiT में शामिल models की तुलना में बहुत बड़े हैं, इसलिए इनमें abstraction की परतें और भी समृद्ध हो सकती हैं
  • विज्ञान के multiple-choice सवालों पर fine-tuning करना शायद model के अंदर पहले से मौजूद क्षमता और ज्ञान को बाहर लाने जैसा काम हो सकता है
    • ज़रूरी weight adjustment बहुत कम हो सकता है
    • एक pre-trained language model, जिसके ऊपर छोटा random classification head जोड़ा गया हो, ऐसे बिंदु पर हो सकता है जहाँ से smooth ढंग से अच्छे weight setting तक पहुँचा जा सके
    • Adam optimizer में अगर gradient लगातार और smooth हों, तो effective dynamic learning rate बढ़ सकता है और बड़े step संभव हो सकते हैं

fine-tuning strategy पर उठते सवाल

  • अगर model बहुत तेज़ी से सीखता है, तो training के पुराने बुनियादी assumptions हिल सकते हैं
    • धीमे सीखने वाले model विविध data को कई epoch तक देखकर धीरे-धीरे generalizable information निकाल सकते हैं
    • तेज़ सीखने वाले model देखे गए examples को तुरंत याद कर सकते हैं और अलग तरह के behavior पैदा कर सकते हैं
  • catastrophic forgetting अधिक स्पष्ट हो सकता है
    • बहुत आम relation के 10 examples देखने के बाद अगर model कम आम counterexample 1 देखे, तो वह पहले के 10 examples की याद थोड़ी कम करने की बजाय उस counterexample को ही याद कर सकता है
  • data augmentation का overfitting रोकने वाला असर भी कमज़ोर पड़ सकता है
    • अगर LLM input information का representation बहुत अच्छी तरह निकालता है, तो paraphrasing या back-translation मिलाने पर भी उसे व्यवहार में लगभग वही जानकारी मिल रही होगी
  • संभावित उपायों में dropout और stochastic depth शामिल हैं
    • dropout पहले से LoRA जैसी fine-tuning techniques में थोड़ा इस्तेमाल होता है
    • stochastic depth का NLP में अर्थपूर्ण स्तर पर इस्तेमाल अब तक कम दिखाई देता है
  • एक और तरीका यह है कि training के पूरे दौरान समृद्ध dataset mixing बनाए रखा जाए
    • Llama Code ने coding performance बढ़ाते समय ऐसा catastrophic forgetting झेला जिसमें दूसरी क्षमताएँ काफ़ी बिगड़ गईं
    • उस समय non-code data का हिस्सा 10% था
    • अगर mixing लगभग 50/50 के करीब होती, तो संभव है coding performance पाते हुए पुरानी क्षमताएँ भी बची रहतीं

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

1 टिप्पणियां

 
GN⁺ 2023-09-07
Hacker News की राय

  • इस लेख को HN पर डालने के लिए धन्यवाद। मैं इस लेख के सह-लेखकों में से एक हूं, और Johno के साथ LLM की तेज़ memorization नाम की इस अजीब phenomenon में गहराई से जाना वाकई दिलचस्प रहा
    मैं 30 साल से neural networks पर काम कर रहा हूं और 2017 से language model fine-tuning कर रहा हूं, लेकिन यह behavior बहुत चौंकाने वाला था। दूसरों ने भी LLM में इसी तरह की phenomena देखी हैं, लेकिन इस तरह का analysis अभी नहीं देखा है, और शायद हमसे कुछ छूट भी गया हो

    • Palm-E paper (https://palm-e.github.io/) में यह बात दिलचस्प है कि अगर LLM को unfreeze करके सिर्फ नए image data पर train किया जाए, तो जैसा expected है, natural language processing tasks में catastrophic forgetting बहुत ज़्यादा होता है, लेकिन training से पहले LLM का scale जितना बड़ा होता है, उसका असर उतना ही कम हो जाता है
      12B model में औसतन -87.3%, 84B में -61.6%, और 562B में सिर्फ -3.9% performance drop था। लगा जैसे कोई insight बस मिलने ही वाली है, और मैं सोच रहा हूं कि क्या catastrophic forgetting से बचना बस scale का मामला हो सकता है
    • मुझे लगता है कि base model क्या है, यह छोड़ देना एक बड़ी गलती है, और इसे सामान्य तौर पर LLM की phenomenon नहीं मानना चाहिए
      मैं researcher नहीं हूं, लेकिन यह साफ है कि सभी LLM की architecture एक जैसी नहीं होती, और समान architecture होने पर भी वे same input पर functionally काफी अलग behave करने के लिए evolve हो सकते हैं। फिर भी कई लेख LLM को मानो एक ही architecture और model की तरह treat करते दिखते हैं
    • Jeremy, मुझे आपका काम हमेशा पसंद आता है। Astronomy मेरा specialization है, इसलिए technically जोड़ूं तो यहां बताया गया MOND example असल में option (E) सही होना चाहिए
    • Jeremy, अगर आप batch का loss एक बार calculate करें और gradient update करने के बाद no_grad के साथ उसी batch का loss फिर से calculate करें, तो शायद आप exact calculate कर सकते हैं कि model ने एक step में कितना सीखा
      batch या observation/question level पर first loss और second loss का difference plot करें, तो दिलचस्प results मिल सकते हैं
    • बहुत दिलचस्प। पहले Hugging Face transformers issue में भी ऐसी ही बात आई थी, और उस समय भी memorization को सबसे likely वजह माना गया था। अच्छा लगा कि दूसरी तरफ से भी same conclusion निकला
      https://github.com/huggingface/transformers/issues/18730

  • पता नहीं लोग सच में “over confident” expression का मतलब यही लेते हैं या नहीं। यह काफी misleading expression है, और यहां जो हो रहा है उसे overfitting कहना सही होगा
    data को points की तरह सोचें, तो अच्छा generalize करने वाला model training data points को काफी ठीक से fit करने वाला सबसे simple function बनाने की कोशिश करता है। लेकिन training जारी रखने पर parameters बहुत बड़े हो सकते हैं, और function curve training data से exact होकर गुजरने के लिए actual data range से बहुत बाहर जाकर काफी oscillate कर सकता है
    इसलिए technically वह training data पर बेहतर fit होता है, लेकिन नए data पर extreme outputs देने वाला अजीब function बन जाता है और generalization लगभग worst हो जाता है। हालांकि overfitting memorization जैसा नहीं है। बड़े models छोटे datasets को overfit किए बिना भी memorize कर सकते हैं, और parameters इतने ज़्यादा होते हैं कि training data fit करने के लिए बहुत कम बदलाव चाहिए होता है। इस case में learning रुक जाती है लेकिन generalization नहीं होती, और ऐसे case को underdetermined कहा जाता है
    कुछ models output के साथ confidence भी देते हैं, इसलिए “overconfidence” का मतलब यह भी हो सकता है कि model ने high confidence, यानी low error variance, गलत predict किया

    • अगर output probabilities पर argmax apply किए गए neural network को function माना जाए, तो यह बिल्कुल overfitting नहीं है। unseen data, यानी validation set पर classification accuracy लगातार बेहतर हो रही है
      यहां core issue calibration है: https://en.m.wikipedia.org/wiki/Calibration_(statistics). इसका मतलब है कि neural network की output probabilities actual observed probabilities को reflect नहीं करतीं। अगर probabilities systematically कम estimate हों तो उसे “underconfidence”, और ज़्यादा estimate हों तो “overconfidence” कहा जाता है
      इस case में calibration खराब होने से validation loss बढ़े, फिर भी unseen data के लिए classifier अभी भी improve हो सकता है
    • जिस model की accuracy बेहतर हो रही हो, उसके लिए overfitting शब्द इस्तेमाल नहीं करते। मुझे यह misleading लगता है
    • training set loss बेहतर हुआ और validation set loss खराब हुआ, इसलिए मुझे लगता है कि यह एक तरह का overfitting है। हालांकि यह उस common overfitting से अलग है जहां validation set accuracy खराब होती है
      यहां validation data accuracy लगातार बेहतर हुई, लेकिन जब model गलत होता है तो पहले से ज़्यादा confidence के साथ गलत होता है। जैसे पहले वह answer X है, ऐसा 60% confidence से गलत कहता था, और अब भी X कहकर गलत है लेकिन 70% जैसे ज़्यादा confidence के साथ। इसलिए यह overfitting का अजीब रूप है, और “overconfidence” जैसा अधिक specific expression ठीक लगता है

  • मैं LLM expert नहीं हूं, लेकिन सामान्य machine learning perspective से यह इतना surprising नहीं है
    हमारे पास billions of parameters वाला generative model है, जो fine-tuning samples को पहले से कुछ probability mass assign कर रहा है। अब उस probability mass को बढ़ाने वाला gradient calculate किया जाता है और उस direction में एक step लिया जाता है। आखिर में लेखक इस बात से हैरान हैं कि वह एक step sample की probability mass को काफी बढ़ा देता है
    लेकिन generative models बेहद overparameterized होते हैं, और fine-tuning sample को पहले से कुछ probability mass दे रहे होते हैं। billions-dimensional parameter space में relatively कम samples की probability तेजी से बढ़ाने वाली direction न हो, तो वही ज़्यादा हैरान करने वाली बात होगी

    • मेरा भी यही विचार था। यह बिल्कुल surprising नहीं लगा, इसलिए लगा कि शायद मैं कुछ miss कर रहा हूं

  • मुझे लगता है कि ज्यादातर LLM अभी एक epoch ही train किए जाते हैं, इस fact से यह result पहले से कुछ हद तक साफ नहीं था क्या
    क्योंकि अगर सिर्फ एक epoch train किया जाए, तो data को दूसरी बार sweep करने मात्र से भी overfitting की चिंता हो सकती है। हालांकि यह इस paper [0] के result से कुछ उलटा लगता है, जिसमें पाया गया कि old data भी कम से कम 4 epochs तक new data जितना अच्छा है
    [0]: https://arxiv.org/abs/2305.16264

    • छोटा correction: public LLM में से काफी सारे कम से कम एक epoch से थोड़ा अधिक train किए जाते हैं, और आम तौर पर Wikipedia जैसे specific data subsets पर कई epochs चलाए जाते हैं
    • ऐसा नहीं है कि केवल एक epoch train होते हैं। high-quality data पर कई epochs चलाए जाते हैं। Meta की Llama team ने भी दिखाया है कि ज़्यादा, और ज़्यादा tokens के साथ train करने पर loss लगातार घटता है

  • शायद संबंधित न हो, लेकिन मैंने ChatGPT से PowerShell में Excel स्प्रेडशीट के कॉलम फ़िल्टर की डिटेल्स को प्रोग्रामेटिक तरीके से नियंत्रित करने वाला code लिखवाने की कोशिश की थी
    जो भी कोशिशें कीं, सब नाकाम रहीं; वह बहुत करीब पहुँचा, लेकिन काम नहीं किया। अंत में मैंने समस्या ठीक करने वाला C# code ढूँढा, उसे ChatGPT में पेस्ट करके पढ़वाया और फिर PowerShell में समस्या ठीक करने को कहा। उसने कहा कि उसे समाधान समझ आ गया है, script को बदला, और वह पूरी तरह काम कर गई
    किसी वजह से यह व्यवहार मेरे लिए काफी आँखें खोलने वाला अनुभव था। सवाल के अंदर ऐसी सामग्री देने पर, जिस पर उसे trained नहीं किया गया था, उसने समाधान निकाल लिया। language learning के नज़रिए से यह कैसे संभव है, यह समझ आता है, लेकिन LLM ऐसा कर सकता है, यह सचमुच कमाल लगा

    • दिलचस्प किस्सा है। मुझे लगता है कि अभी LLM को लेकर लोगों में एक आम रुझान है कि वे model में knowledge retrieval पर बहुत ज़्यादा ध्यान देते हैं, और “language model” वाले हिस्से को कम आँकते हैं
      ये चीज़ें बोलने और समझाने में अच्छी हैं, इसलिए इन्हें आसानी से मानवीय रूप दे दिया जाता है। ये इतनी अच्छी हैं कि statistical engineering की विशाल, जादुई उपलब्धि को हम एक मामूली basic building block की तरह मानने लगते हैं। लेकिन वह block सोने की ईंट है
      natural language से code में, text से audio में, image से image में, एक natural language से दूसरी natural language में translate करना, edit करना, summarize करना, expand करना और extrapolate करना—यही ये models करते हैं। इनमें अंतर्निहित “knowledge” बस context है
      vector embedding को मैं थोड़ा अलग तरह से देखता हूँ; यह Dewey decimal जैसी semantic cataloging का एक रूप है, जो search को संभव बनाता है। लेकिन “1984 में अमेरिका के राष्ट्रपति कौन थे” जैसी data retrieval को सीधे model से कराना निजी तौर पर मुझे बहुत दिलचस्प नहीं लगता

  • मुझे उत्सुकता है कि क्या LLM का इस्तेमाल कभी अपने training data को बढ़ाने के लिए हुआ है
    अगर LLM को कम input पर train किया जाए, फिर वह बहुत सारे synthetic input generate करे और उन्हें training data में जोड़ दिया जाए, तो क्या होगा—यह जानना चाहता हूँ। मैं इसे एक तरह की “dreaming” जैसा सोच रहा हूँ। शायद यह सिर्फ noise ही जोड़ दे, लेकिन LLM खुद context को बढ़ाकर “thinking out loud” के जरिए output सुधार सकता है, तो क्या training data के साथ भी वैसा नहीं कर सकता?

    • हाँ। हाल की काफी research LLM output को training data के रूप में इस्तेमाल कर रही है, और यह research direction बहुत सफल रहा है
    • असल में RLHF यही है। अच्छे और बुरे output क्या हैं, यह बताने वाले छोटे human-curated dataset को guideline बनाकर LLM को सिर्फ अपने output से self-train कराने का तरीका है
    • दिलचस्प बात है कि यह निष्कर्ष sibling comment के ठीक उलट है, जहाँ माना गया है कि छोटा human-curated corpus बड़े synthetic dataset से अधिक प्रभावी हो सकता है
    • अगर model उसी data पर train होता है जो उसने खुद generate किया है, तो system में नई जानकारी नहीं जुड़ती। वह जो पहले से सही guess करता है और जो गलत करता है, दोनों को reinforce करेगा, इसलिए सुधार नहीं होगा
      हाँ, बड़े model से synthetic training data बनाकर किसी छोटे, अलग model को train करना आम है। इस तरह एक model का knowledge दूसरे model में transfer किया जा सकता है
    • आप यह खुद करके जवाब पा सकते हैं। किसी model के हिसाब से random data generate करें, linear regression या कोई और distribution fit करें, फिर उस distribution से sample लेकर training set में जोड़कर देखें

  • मुझे लगता है title भ्रम पैदा करता है
    learning के context में एक ही example से सीखना वांछनीय है, और memorization वांछनीय नहीं—क्या ऐसा नहीं है? पहला वह लक्ष्य है जिसे animals के सीखने के तरीके से मिलाने के लिए अपनाया जाता है, और दूसरा अक्सर होने वाला failure mode है। लेख learning नहीं, बल्कि बिना समझाए हुए memorization का उदाहरण दिखाता लगता है

  • ViT को scratch से train करते समय मैंने ऐसी ही loss curve देखी थी, और यह हमेशा खटकती रही, लेकिन बड़े मुद्दे थे इसलिए गहराई से नहीं देखा
    फर्क यह है कि हर epoch के दौरान training loss ऊपर जाता है। epochs के बीच की तेज गिरावट इतनी बड़ी होती है कि कुल मिलाकर training loss नीचे जाता है और validation loss भी लगातार नीचे जाता है। model latest level के काफी करीब पहुँच जाता है, इसलिए यह “normal” सा लगता है
    मैंने इस scale पर convolutional neural network train नहीं किया है, इसलिए नहीं जानता कि वहाँ भी ऐसा दिखा था या नहीं, लेकिन अगर ऐसा हुआ होता तो शायद किसी ने ज़िक्र किया होता। इसलिए मुझे लगता है कि ऐसी अजीब loss curve खास तौर पर Transformer-based models की विशेषता हो सकती है

    • मूल लेख में कहा गया था कि LLM को मजबूत abstraction की जरूरत होती है, और Transformer network मूल रूप से ऐसा ही मामला है; scratch से train करते समय यह साफ दिखता है
      model लंबे समय तक लगभग कहीं नहीं पहुँचता और पूरी तरह बेकार दिखता है, फिर किसी क्षण कई training cycles के बाद weights error surface के किसी minimum को खोज लेते हैं और अचानक वह ठीक से काम करना शुरू कर देता है। ऐसा इसलिए क्योंकि Transformer ने attention mechanism के perspective से सभी input data पर काम करने वाला abstraction सीख लिया होता है। पढ़ते समय वाक्यों को scan करने के तरीके के बारे में सोचें। मैं यह HN पर पहले देखे एक लेख को याद करके समझा रहा हूँ, इसलिए यह perfect explanation नहीं है
    • मैंने दूसरों की training loss curves में भी देखा है कि epoch के दौरान loss ऊपर जाता है और epoch के अंत में अचानक काफी गिरता है। खुद अनुभव नहीं किया, और कारण बिल्कुल नहीं जानता
    • पहले epoch के बाद, current data item को last time training में इस्तेमाल किए जाने के बाद से औसत समय epoch की शुरुआत में कम होता है और epoch आगे बढ़ने के साथ बढ़ता जाता है। मुझे उम्मीद है कि उस समय का current iteration के loss के साथ positive correlation होगा
    • अगर पहले epoch में भी loss ऊपर जा रहा है, तो यह थोड़ा अजीब लगता है

  • अब सोच रहा हूँ कि क्या model weights के हिस्से के रूप में current chat context जैसी जानकारी को तुरंत सीखना या याद कर लेना computationally efficient है
    hippocampus जिस one-shot encoding में बहुत अच्छा है, वह अनुभवों को पहले सीखे गए semantic concepts से जुड़ी searchable memories में बदलने देता है। असल में बचपन से adulthood की ओर जाते हुए, events की semantic conceptualization जितनी समृद्ध होती जाती है, यह उतना बेहतर होता जाता है
    अगर LLM में events की memorization इस गहरे semantic framework की वजह से तेज होती है, तो क्या यह long context window की दिशा में कोई रास्ता दे सकता है?

    • हो सकता है, लेकिन बहुत कुछ अज्ञात है। समस्या यह है कि instant memorization कहीं दूसरी जानकारी के catastrophic forgetting के साथ तो नहीं आती, और हाल की चीज़ों को memorize करने व पुरानी चीज़ों को याद रखने को कैसे control किया जाए
    • सिर्फ एक beginner की सोच है, लेकिन idea अच्छा लगता है। आपको अपनी एक modifiable model copy चाहिए होगी, और आम तौर पर वह बहुत बड़ी होती है। साथ ही backpropagation चाहिए, इसलिए computation भी थोड़ा और लगेगा
      GPT-3.5/4 से छोटे local models के लिए यह संभव हो सकता है। साथ ही यह तय करना होगा कि क्या long-term memory में रखना है और क्या short-term memory में

  • अगर यह सच है, तो यह इस विचार को समर्थन देता है कि LLM द्वारा बनाए गए synthetic dataset की तुलना में कहीं छोटे मानव-क्यूरेटेड dataset की वैल्यू बहुत ज्यादा हो जाती है

    • जिसके पास सबसे ज्यादा जानकारी है, वही जीतता है। अगर जानकारी में structure हो, तो उसका बड़ा फायदा उठाकर synthetic data बनाया जा सकता है
      उदाहरण के लिए Apple Sim को लिया जा सकता है। यह indoor 3D model repository है, जहां renderer को control करके कई स्तरों की जानकारी बनाई जा सकती है और फिर उसे असली photos में इस्तेमाल किया जा सकता है। Images में व्यापक रूप से यह तरीका इस्तेमाल होता है, इसलिए vector space embeddings के लिए काफी natural है। Algebraic तरीके से कहें तो बहुत ज्यादा structure जोड़ने की जरूरत नहीं पड़ती
      अगर domain का स्वभाव काफी algebraic है, तो सही examples को arbitrarily generate भी किया जा सकता है, और मैं ऐसे हालात की सिफारिश सभी को करना चाहूंगा
    • Google करीब 2 साल पहले इस निष्कर्ष पर पहुंच गया था, लेकिन अभी तक कोई स्पष्ट परिणाम नहीं दिखा पाया है। ऊपर key word क्यूरेटेड है
    • quantity और quality का संतुलन बनाने वाला कोई value metric होगा, और अभी जैसे समय में, जब हमें technology के काम करने की मध्यम स्तर की समझ है, शायद उस metric का उपयोग किया जा सकता है। यानी synthetic data से मिलने वाला potential gain मौजूद है
      हालांकि मुझे लगता है कि किसी दिन “free lunch” न होने का सिद्धांत लागू होगा, और synthetic data हमेशा outliers के data-generation process की परवाह भी नहीं करता
    • सहमत होना मुश्किल है। बल्कि मुझे लगता है कि ULMFiT के दौर की AI ने आखिरकार मानव-क्यूरेटेड data की जरूरत खत्म कर दी
      ChatGPT 4 पहले से ही रोज़मर्रा के AI models को train करने के लिए oracle model के रूप में इस्तेमाल हो रहा है। सचमुच विशाल oracle model बहुत थोड़े मानव input को छोड़कर बाकी ज्यादातर चीजों को अनावश्यक बना देगा
    • हम इन चीजों को सिर्फ theory में ही क्यों समझा पाते हैं? हम यह क्यों नहीं जान पाते कि ये चीजें कैसे और क्यों काम करती हैं?