Self-Adapting बड़े भाषा मॉडल

• मौजूदा LLM में नया ज्ञान या task इनपुट किए जाने पर भी अक्सर weights वैसे ही रहते हैं; SEAL एक self-adapting framework प्रस्तावित करता है जिसमें मॉडल खुद learning data और procedures बनाकर उन्हें update करता है
• मुख्य unit self-edit जानकारी को फिर से संरचित करता है, optimization hyperparameters तय करता है, और data augmentation तथा gradient-based update tools को call करना भी शामिल करता है
• SEAL updated model की downstream performance को reward बनाकर reinforcement learning loop के जरिए अधिक प्रभावी self-edit generation policy सीखता है
• knowledge integration प्रयोग में, self-generated synthetic data से fine-tune करने के बाद no-passage-in-context SQuAD performance 33.5% से 47.0% हो गई, जो GPT-4.1 द्वारा बनाए गए synthetic data से अधिक थी
• simplified ARC-AGI subset के few-shot learning में भी data augmentation, learning rate, epoch, और token type के हिसाब से loss calculation को अपने-आप चुनकर standard ICL और RL के बिना self-editing से बेहतर नतीजे दिए

---

static LLM को खुद update करने का तरीका

• मौजूदा LLM शक्तिशाली हैं, लेकिन static हैं, और नए tasks, knowledge या examples के अनुसार weights को adapt करने का कोई mechanism नहीं रखते
• SEAL(Self-Adapting LLMs) को इस तरह design किया गया है कि नया input मिलने पर model खुद learning data और learning procedure बदलकर self-adapt करे
• इसका मुख्य output self-edit है
  • जानकारी को किसी दूसरे format में restructure कर सकता है
  • optimization hyperparameters specify कर सकता है
  • data augmentation और gradient-based updates के लिए tools call कर सकता है
• self-edit supervised fine-tuning (SFT) के जरिए model weights के persistent updates तक पहुंचता है
• website और code https://jyopari.github.io/posts/seal पर हैं

मौजूदा adaptation तरीकों से फर्क

• आज के LLM जब नया task पाते हैं, तो आम तौर पर fine-tuning या in-context learning के जरिए task data को as-is consume करते हैं
• input data learning के लिए optimal format या मात्रा में न भी हो सकता है, लेकिन मौजूदा approaches model को यह strategy खुद evolve करने नहीं देते कि data को कैसे transform कर सीखना है
• SEAL किसी अलग adaptation module या auxiliary network पर निर्भर नहीं करता; यह model के अपने generated output से adaptation process को parameterize और control करता है
• यह उस तरीके जैसा है जिसमें human student raw material को ज्यों-का-त्यों याद करने के बजाय notes के रूप में reinterpret और restructure करके सीखता है
  • हर व्यक्ति visual diagrams, text, mathematical explanations जैसे अलग-अलग तरीकों से जानकारी assimilate करता है
  • SEAL इसी restructuring और rewriting process को LLM training procedure में लाने की कोशिश है

reinforcement learning से self-edit policy सीखना

• SEAL reinforcement learning algorithm से LLM को प्रभावी self-edit generate करने के लिए train करता है
• प्रत्येक reinforcement learning outer loop iteration इस flow में चलती है
  • model candidate self-edit generate करता है
  • self-edit के अनुसार weight updates apply किए जाते हैं
  • updated model को downstream task पर evaluate किया जाता है
  • evaluation result से मिले reward के आधार पर self-edit generation policy improve की जाती है
• reward signal updated model की downstream performance है

प्रयोगों के नतीजे: knowledge integration

• knowledge integration प्रयोग LLM में नया factual knowledge डालने के task से जुड़ा है
• passage text को directly fine-tune करने के बजाय, SEAL model द्वारा generated synthetic data से fine-tuning की गई
• reinforcement learning training के बाद SEAL के self-generated synthetic data ने no-passage-in-context SQuAD question-answering performance को 33.5% से 47.0% तक बढ़ा दिया
• SEAL के self-generated data ने GPT-4.1 द्वारा बनाए गए synthetic data से ज्यादा performance दर्ज की

प्रयोगों के नतीजे: ARC-AGI few-shot generalization

• दूसरा evaluation simplified ARC-AGI benchmark subset पर few-shot learning करता है
• model tool set का उपयोग करके synthetic data augmentation और optimization hyperparameters को autonomously चुनता है
• automatic selection में ये items शामिल हैं
  • learning rate
  • training epochs
  • token type के हिसाब से selective loss calculation
• SEAL के जरिए tools की automatic selection और configuration ने standard in-context learning (ICL) और tools का effectively इस्तेमाल करना नहीं सीखने वाली RL-रहित self-editing से बेहतर performance दी
• दोनों प्रयोग दिखाते हैं कि SEAL नए data के जवाब में language model को self-directed तरीके से adapt कराने वाला framework बन सकता है

[GN⁺]

Hacker News की राय

• self-edit approach इस मायने में चतुर है कि यह reinforcement learning के जरिए उस तरीके को optimize करता है जिससे model अपनी self-learning के लिए जानकारी को फिर से संरचित करता है
  मूल बात यह है कि हर तरह के ज्ञान के लिए अलग expression बेहतर बैठता है, कुछ वैसा ही जैसे इंसान गणित और इतिहास पढ़ते समय अलग-अलग तरह से notes बनाते हैं
  GPT-4.1 data पर knowledge integration के नतीजे 47% बनाम 46.3% के साथ छोटे model baseline से काफी ऊपर हैं, इसलिए लगता है कि यह सिर्फ data बढ़ने का मामला नहीं, बल्कि बेहतर learning format खोजने का मामला है
  हालांकि catastrophic forgetting अब भी हल नहीं हुआ है, और यह भी पूरी तरह साफ नहीं है कि data diversity सच में बेहतर हुई है या नहीं
  हर reward evaluation में 30–45 सेकंड लगने की compute cost ज्यादातर उपयोगों के लिए बहुत भारी है, लेकिन अगर optimal preservation सचमुच जरूरी हो, जैसे high-value document processing में, तो यह काम आ सकता है
  explicit evaluation metrics वाले tasks तक सीमित होना इसकी सबसे बड़ी सीमा है, और reward calculate करने के लिए सही question-answer pairs या test cases चाहिए
  फिर भी technical documentation या educational content जैसे क्षेत्रों में, जहां evaluation generate की जा सकती है, यह नई जानकारी को process करने के तरीके को काफी बेहतर बना सकता है; भले ही यह अभी “लगातार खुद को सुधारने वाले agent” के चरण में न हो, model द्वारा अपनी learning strategy adjust करने की दिशा में यह एक अहम कदम लगता है

• 2010 के दशक के मध्य से ही machine learning बहुत जल्दी शुरू कर चुके गणित में प्रतिभाशाली मेरे दो दोस्त अक्सर NEAT/HyperNEAT algorithms के बारे में बात करते थे, जो इससे मिलते-जुलते लगते हैं
  “NEAT/HyperNEAT” (Neuroevolution of Augmented Topologies) [0]
  मैं machine learning expert नहीं हूं, लेकिन मेरी समझ के मुताबिक NEAT network की topology को evolve करता है, और यह paper weights को evolve करता लगता है
  आखिरकार, एक network structure को और दूसरा weights को evolve करते हुए, उसी समस्या को हल करने के दो approaches जैसे दिखते हैं
  वे दोनों दोस्त मेरे मिले सबसे होशियार लोगों में थे, और उन्हें काफी भरोसा था कि reinforcement learning और evolutionary algorithms ही machine learning का आगे का रास्ता हैं
  [0] https://en.wikipedia.org/wiki/Neuroevolution_of_augmenting_t...

  • इंसान कमाल हैं। neurons को समझने के लिए उन्होंने एक काल्पनिक computational system बनाया, फिर पता चला कि असली neurons वैसे काम नहीं करते, लेकिन फिर भी उसी पर paradigm बदल देने वाली technology बना दी
    और अब भी वे उस काल्पनिक system से निकले ideas से technology को मजबूत कर रहे हैं
  • मेरी पसंदीदा NEAT introduction material SethBling की MarI/O - Machine Learning for Video Games है
    https://www.youtube.com/watch?v=qv6UVOQ0F44
  • हाल में मैं इस idea में पूरी तरह डूब गया हूं। Kokoro के लिए voice cloning को genetic algorithm से कुछ हद तक सफल करने के बाद, मुझे जिज्ञासा हुई कि क्या architecture itself को evolve किया जा सकता है
    self-assembling intelligence का idea बहुत दिलचस्प है, लेकिन इसे व्यवहार में संभव कैसे बनाया जाए, यह सवाल है
    LLMs जिस तरह अब तक आगे बढ़े हैं, उसे देखते हुए ऐसे hybrid approaches ही शायद सबसे अच्छे हों

• Anthropic से भी कुछ दिन पहले self finetuning से जुड़ा paper आया था
  https://arxiv.org/html/2506.10139v1

  • यह बहुत बड़ा है
    “Claude 3.5 Sonnet के production-grade reward model से evaluate करने पर, unsupervised assistant policy ने human-supervised reward model से trained policy के head-to-head comparison में 60% जीत हासिल की”
    यानी अब models नए models की post-training भी इंसानों से बेहतर कर सकते हैं
  • इससे जुड़ा एक ongoing thread है
    Unsupervised Elicitation of Language Models - https://news.ycombinator.com/item?id=44276041

• काश कोई जानकार यह summarize कर दे कि LLMs को “काम करते समय” सीखने देने वाली research कहां तक पहुंची है, और इसे असल में deployable चीज बनने से रोकने वाली बाधाएं क्या हैं
  उदाहरण के लिए, continual fine-tuning जैसे तरीकों से समय के साथ codebase को सचमुच सीखने वाला model+coding agent बनाते समय cost, model collapse या अन्य factors में से क्या समस्या है, यह जानना चाहूंगा
  बड़े labs निश्चय ही इस पर कोशिश कर रहे होंगे, लेकिन LLM user के नजरिए से इस बारे में ज्यादा चर्चा नहीं दिखती, और अभी ध्यान बेहतर training, जैसे reinforcement learning, पर केंद्रित लगता है
  यह assumption भी छिपी दिखती है कि जो training के दौरान नहीं सीखा गया, उसे जरूरत पड़ने पर context में डाल दिया जाएगा
  भोले-भाले नजरिए से देखें तो training के बाद experience से न सीख पाना AGI की राह की सबसे बड़ी बाधा जैसा लगता है

  • हमें continual learning कैसे करनी है, यह बिल्कुल नहीं पता
    compute cost, collapse, forgetting जैसी बातें सही हैं, लेकिन एकमात्र “वास्तविक” रूप से संभव तरीका यह है कि model train करें, नया data लें, पुराने पूरे data और नए data के साथ model को पूरी तरह retrain करें, और इसे दोहराते रहें
    फिर भी “time” वाले पहलू पर कोई guarantee नहीं है
    continual learning के क्षेत्र में सही मायने में इसे हल करने वाले जवाब बहुत कम हैं, और solutions कई मायनों में self-contradictory हैं, इसलिए यह पागल कर देने जितना कठिन है
    पुराने representation space को लगभग वैसा ही रखते हुए model के representation space को expand करना पड़ता है, यानी अंततः बिना बदले बदलना पड़ता है
    सबसे झुंझलाने वाली बात यह है कि बहुत छोटे प्राकृतिक brains भी यह आसानी से कर लेते हैं
    इस पर लंबा सिद्धांत समझाया जा सकता है, लेकिन संक्षेप में कहें तो AI को भी किसी न किसी तरह सोने या आराम करने की प्रक्रिया की जरूरत हो सकती है
  • मैं expert नहीं हूं, लेकिन लगता है privacy की बड़ी भूमिका है, या होनी चाहिए
    compute cost के कारण कोई भी training शायद user-level पर नहीं बल्कि aggregated तरीके से करनी पड़ेगी, और तब sessions के बीच information leakage का जोखिम बहुत बढ़ जाता है
    मैं पूरी तरह सहमत हूं कि सुरक्षित continual learning का तरीका ढूंढना AGI की सबसे बड़ी बाधा जैसा है
  • असली जवाब यह है कि हम automatic evaluation पर पर्याप्त भरोसा नहीं करते
    evaluation score बढ़ जाने पर भी यह निश्चित करना कठिन है कि automatically trained कोई specific release वास्तव में performance improve कर रहा है, इसलिए फिलहाल सभी updates को batch करके जारी करते हैं और deployment से पहले sanity check करते हैं
  • सबसे स्पष्ट समस्या alignment है
    यह पहले से पता है कि सिर्फ LLM fine-tuning से भी alignment खत्म हो सकता है, इसलिए किसी भी रूप की continual fine-tuning सैद्धांतिक रूप से उसी तरह alignment हटा सकती है
  • सबसे साफ बाधा catastrophic forgetting है

• देखने में यह सिर्फ़ ऐसा framework लगता है जो LoRA adapter को fine-tune करने के बाद उसे मूल model में merge करता है
  HuggingFace library के PeftModel और merge_and_unload का इस्तेमाल करके adapter को base model में merge किया जाता है, लेकिन ठीक-ठीक नया क्या है, समझ नहीं आता

  • नया दिखने वाला हिस्सा शायद approach की stability, alignment cost और model collapse से बचने में हो सकता है
    generated LoRA से दोनों models को लगातार update करते हुए, और hypernetwork को भी नए model state के मुताबिक update करते हुए hypernetwork का पूरा loop देखना चाहूंगा
    hypernetwork पर LoRA लागू करने के लिए meta-hypernetwork चाहिए होगा, और तब असल में continual learning संभव हो सकती है

• “बड़े language models शक्तिशाली हैं, लेकिन static हैं, और नए tasks के जवाब में weights adjust करने का कोई mechanism नहीं है” वाला हिस्सा मुख्य है
  training और inference process पूरी तरह अलग हैं, इसलिए human intelligence की पारंपरिक धारणा से परिचित लोगों के लिए यह बहुत confusing है
  इंसानों में कुछ सीखना और उस ज्ञान को वास्तविकता में लागू करना एक integrated feedback process है, लेकिन LLM में ऐसा नहीं है
  हम train करते हैं, deploy करते हैं, और थोड़े और “सीखे हुए” नए model से replace कर देते हैं
  LLM के लिए inference, learning का अंत है
  शायद AI को लेकर सबसे बड़ी गलतफहमी यहीं है
  अगर आप सोचते हैं कि LLM सीख रहा है, तो AGI बस आने ही वाली है, ऐसी कल्पना करना आसान हो जाता है

  • DeepSeek ने जैसा दिखाया, reinforcement learning से LLM को refine किया जा सकता है
  • अगर user output पर positive या negative प्रतिक्रिया देता है, तो उसे देखकर model को मिले input और उसके generated output से LLM को train किया जाए तो कैसा रहेगा?

• code और examples वाली website: https://jyopari.github.io/posts/seal

• इस क्षेत्र में सही तरह से भूलना, “सही तरह से सीखने” से ज़्यादा महत्वपूर्ण समस्या तेज़ी से बनती दिख रही है
  models को नए facts खुद सिखाने में बड़ी प्रगति हुई है, लेकिन नए knowledge और सीमित capacity को देखते हुए सबसे कम relevant जानकारी को discard करने की state-of-the-art techniques काफ़ी पीछे हैं
  human brain का अधिकांश हिस्सा “सही तरह से भूलने” में बहुत अच्छा है, और सोचता हूं यह कैसे काम करता है

  • मुझे नहीं लगता कि इंसान सच में सही तरह से भूलने में इतने सक्षम हैं
    सच कहूं तो मुझे इस बात पर भी यकीन नहीं कि human brain हमारी कई गतिविधियों में “असाधारण रूप से उत्कृष्ट” है
    human brain की memory capacity इतनी बड़ी है कि ज्यादातर forgetting नई जानकारी के लिए जगह बनाने से ज़्यादा इस बात से जुड़ी लगती है कि brain सही तरह से जानता है कि पुरानी खराब जानकारी नई learning में बाधा डालती है
  • जहां तक मुझे पता है, artificial neural networks में यह identify करने में बहुत कम progress हुई है कि कौन-सा weight किस output के लिए कितनी जिम्मेदारी रखता है
    इसलिए user द्वारा गलत, inaccurate या undesirable बताई गई जानकारी को discard नहीं किया जा सकता
    इसके उलट human mind यह आसानी से कर लेता है
    वह याद रखता है कि कोई चीज़ गलत, बेकार या irrelevant के रूप में classified है और उसे दोबारा नहीं करता, और समय के साथ उस कम इस्तेमाल होने वाले path को खुद भी भूल सकता है
    कम से कम artificial neural networks में ऐसा कोई स्पष्ट mechanism नहीं है
  • learning का spaced repetition से गहरा संबंध है
    आम तौर पर इसे Anki जैसे learning tools से जोड़ा जाता है, लेकिन real world चीज़ों को किसी खास frequency पर encounter करने से भरी है
    दिन-रात का cycle, seasons, जिन जगहों पर हम जाते हैं, जिन लोगों से मिलते हैं—असल में लगभग सब कुछ ऐसा ही है
    शायद spaced repetition का कोई reverse रूप भी हो, ऐसा सोचता हूं
  • मैंने एक दिलचस्प research देखी थी, LLM internal data को “छिपाते” भी हैं
    वे सिर्फ़ भूलते नहीं; अगर उन्हें लगातार train किया जाए तो वह जानकारी बाद में फिर सामने आ सकती है
    इसलिए model को train करते समय केवल छोटे हिस्से को देखने के बजाय पूरी memory की जांच करनी चाहिए
  • क्या यह हाल के least-used approach जैसा कुछ है?
    अभी अपने दिमाग में test करके समझने की कोशिश कर रहा हूं :D
    इसी वजह से मुझे computer science का यह क्षेत्र पसंद है

• “Villalobos et al. [75] का अनुमान है कि frontier LLMs 2028 तक सार्वजनिक रूप से उपलब्ध सभी human-generated text पर train हो चुके होंगे” वाला हिस्सा प्रभावशाली है
  paper मानता है कि आने वाली data barrier के कारण synthetic data augmentation अपनानी होगी, और web-scale corpora खत्म होने पर model की खुद उपयोगी learning signals generate करने की क्षमता पर progress निर्भर करेगी
  स्वाभाविक अगला कदम dedicated SEAL synthetic data generation model को meta-learn कराकर नए pretraining corpus बनाना है, ताकि future models अतिरिक्त human text पर निर्भर हुए बिना scalability और data efficiency बढ़ा सकें
  2028 तो व्यावहारिक रूप से कल ही है, और यह दिलचस्प insight है

  • वह सिर्फ़ theory है
    एक single human brain, nodes और connections की संख्या के लिहाज से पूरे web से कहीं अधिक complex है
    हम brain को इतना भी नहीं समझते कि सोच कैसे होती है, यह समझा सकें
    brain output बनाकर web पर भेजने से पहले जो process होती है, उसे भी हम पूरी तरह नहीं समझते
    web-scale के खत्म होने के बाद model खुद उपयोगी training data बना पाएगा—यह prediction बस अनुमान है
    ऐसा training data human thought जैसी quality तक शायद न पहुंचे, और शायद सिर्फ़ दोहराव करता रहे, learning या model quality में कोई progress न करे
    इसे “insight” कहना थोड़ा optimistic है
  • यह तो लगभग अभी की ही स्थिति है
    frontier LLMs पहले ही सार्वजनिक रूप से उपलब्ध लगभग सभी human-generated text पर train हो चुके हैं, और coding जैसे verifiable tasks को improve करने के लिए synthetic data पर भी पहले से काफी train हो रहे हैं