कोड जनरेशन प्रदर्शन को बेहतर बनाने वाली चौंकाने वाली सरल self-distillation तकनीक

 (arxiv.org)
12 पॉइंट द्वारा GN⁺ 2026-04-05 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • Simple Self-Distillation(SSD) एक ऐसी विधि है जिसमें बड़ा language model teacher model या reinforcement learning के बिना खुद द्वारा जनरेट किए गए कोड को दोबारा सीखकर प्रदर्शन बढ़ाता है
  • Qwen3-30B-Instruct मॉडल का LiveCodeBench v6 pass@1 स्कोर 42.4% से 55.3% तक बेहतर होता है, और खासकर कठिन समस्या खंड में +15.3pp सुधार दिखता है
  • SSD कोड जनरेशन के दौरान accuracy और exploration के बीच टकराव को कम करता है, और context के अनुसार tail probability को दबाकर उपयोगी विविधता बनाए रखता है
  • सिर्फ temperature adjustment या decoding policy बदलने से वही प्रभाव दोहराया नहीं जा सकता, क्योंकि SSD मॉडल के आंतरिक distribution को ही पुनर्गठित करता है
  • बाहरी डेटा या verification के बिना लागू किया जा सकने वाला यह सरल post-training learning procedure, LLM कोड जनरेशन गुणवत्ता सुधारने का व्यावहारिक विकल्प प्रस्तुत करता है

सरल self-distillation (Simple Self-Distillation, SSD)

  • SSD(Simple Self-Distillation) एक ऐसी विधि है जिसमें बड़ा language model (LLM) teacher model, verifier, reinforcement learning के बिना अपने ही जनरेट किए गए code output का उपयोग करके प्रदर्शन सुधारता है
    • मॉडल किसी खास temperature और truncation सेटिंग के साथ sample जनरेट करता है, और उन परिणामों को standard supervised fine-tuning (SFT) से फिर से सीखता है
    • किसी भी बाहरी labeled data, reward model, या execution environment की बिल्कुल आवश्यकता नहीं होती
  • Qwen3-30B-Instruct मॉडल का LiveCodeBench v6 pass@1 स्कोर 42.4% → 55.3% तक बढ़ा (+12.9pp, +30% सापेक्ष सुधार)
    • खासकर कठिन समस्याओं (hard split) में सबसे बड़ा सुधार (+15.3pp)
    • Qwen और Llama परिवार के 4B, 8B, 30B मॉडलों में व्यापक रूप से सामान्यीकृत
  • SSD precision-exploration टकराव को कम करने के तरीके से काम करता है
    • कोड जनरेशन के दौरान कुछ token उच्च precision मांगते हैं ("lock"), जबकि कुछ विविध exploration मांगते हैं ("fork")
    • SSD context के अनुसार अनावश्यक tail distribution को दबाते हुए उपयोगी diversity बनाए रखता है

1. शोध पृष्ठभूमि

  • उच्च-गुणवत्ता वाले supervised signal (जैसे मानव-लिखित code) की कमी के कारण LLM code generation प्रदर्शन सुधारने में बाधा आती है
  • मौजूदा approaches की सीमाएँ
    • teacher model आधारित distillation: teacher model की प्रदर्शन सीमा विरासत में मिलती है
    • reinforcement learning (RL): reward model और execution-आधारित verification की जरूरत, साथ ही अस्थिरता
    • unsupervised विकल्प (जैसे majority voting, entropy minimization): लंबे प्रशिक्षण में collapse का जोखिम
  • SSD यह साबित करता है कि बाहरी डेटा या verification के बिना सिर्फ मॉडल के अपने output से सुधार संभव है

2. SSD पद्धति

  • डेटा synthesis

    • दिए गए समस्या prompt सेट X के लिए, मॉडल pθ से temperature Ttrain और truncation सेटिंग ρtrain(top-k, top-p) के साथ sampling
    • जनरेट किया गया output (y) बिना verification सीधे training data (DSSD) के रूप में उपयोग होता है
    • अधिकांश मामलों में N=1 (प्रति समस्या एक sample) पर्याप्त है

  • प्रशिक्षण

    • standard cross-entropy loss के साथ supervised fine-tuning किया जाता है
    • L(θ) = −E(x,y)∼DSSD Σ log pθ(yt | x, y<t)

  • inference

    • प्रशिक्षित मॉडल pθ* को evaluation temperature Teval और truncation सेटिंग ρeval के साथ decode किया जाता है

3. प्रयोग

  • मॉडल संरचना

    • Llama-3.1-8B-Instruct, Qwen3-4B/30B (Instruct, Thinking) सहित 5 मॉडल
    • 2 परिवार (Llama, Qwen), 3 स्केल (4B, 8B, 30B), 2 reasoning शैली (Instruct, Thinking)

  • डेटा

    • rSTARcoder dataset के लगभग 10K competitive programming problems का उपयोग
    • सही उत्तर verification के बिना केवल साधारण syntax filtering लागू की गई

  • प्रशिक्षण सेटिंग

    • Megatron-LM आधारित, 8×B200 GPU का उपयोग
    • AdamW optimizer, अधिकतम sequence length 65,536
    • Instruct मॉडल 2,500 step, Thinking मॉडल 300 step

  • मूल्यांकन

    • LiveCodeBench v6 (LCB v6) को मुख्य benchmark के रूप में उपयोग किया गया
    • pass@1, pass@5, और कठिनाई-आधारित (Easy/Medium/Hard) विस्तृत मूल्यांकन

4. मुख्य परिणाम

  • समग्र प्रदर्शन सुधार

    • Qwen3-30B-Instruct: 42.4% → 55.3% pass@1 (+12.9pp)
    • Qwen3-4B-Instruct: +7.5pp, Llama-8B: +3.5pp
    • Thinking मॉडल में भी +2~3pp सुधार

  • कठिनाई के अनुसार सुधार

    • Qwen3-30B-Instruct: Easy +6.5pp / Medium +14.2pp / Hard +15.3pp
    • Thinking मॉडल में भी Hard खंड में सबसे बड़ा सुधार

  • diversity बनाए रखना

    • pass@5 का सुधार pass@1 से बड़ा → generation diversity बनी रहती है और बेहतर होती है
    • उदाहरण: Qwen3-30B-Instruct pass@5 +18.1pp (Hard +23.0pp)

  • domain generalization

    • competitive programming के बाहर गणित, सामान्य code, और understanding tasks में भी प्रदर्शन बना रहता है

5. decoding policy तुलना

  • केवल temperature adjustment से SSD प्रभाव पुन: उत्पन्न नहीं किया जा सकता

    • Base मॉडल के temperature sweep परिणाम: pass@1 में बदलाव केवल 1.5–3.0pp स्तर का
    • SSD वही परिस्थितियों में +11.8pp (Qwen3-30B-Instruct) सुधार देता है
    • खासकर Hard समस्याओं और pass@5 में अंतर सबसे बड़ा है
    • SSD मॉडल के आंतरिक distribution को स्वयं बदलता है, इसलिए इसे साधारण decoding adjustment से बदला नहीं जा सकता

6. hyperparameter अंत:क्रिया

  • training temperature (Ttrain) और evaluation temperature (Teval) का गुणनफल Teff = Ttrain × Teval प्रदर्शन तय करता है
    • Teff ≈ 1.2 के आसपास सर्वोत्तम प्रदर्शन
    • Ttrain जितना अधिक, Teval बदलाव के प्रति संवेदनशीलता उतनी अधिक
  • truncation जोड़ने पर प्रदर्शन की ऊपरी सीमा बढ़ती है
    • सर्वोत्तम सेटिंग: Ttrain=2.0, Teval=1.1, top-k=10 → pass@1 49.7% (+7.3pp)
    • truncation कम-प्रायिकता tail हटाकर अतिरिक्त सुधार देता है

7. SSD कैसे काम करता है

  • precision-exploration टकराव

    • Lock: वे स्थान जहाँ व्याकरण की दृष्टि से सही उत्तर लगभग तय है → कम temperature की आवश्यकता
    • Fork: वे स्थान जहाँ कई समाधान संभव हैं → अधिक temperature की आवश्यकता
    • एक ही temperature से दोनों जरूरतें पूरी करना कठिन है

  • SSD की भूमिका

    • Lock में tail probability दबाकर precision मजबूत करता है
    • Fork में शीर्ष candidates के बीच probability को समतल कर exploration diversity बनाए रखता है
    • परिणामस्वरूप context-dependent distribution reshaping करता है

8. प्रायोगिक सत्यापन

  • simulated environment प्रयोग

    • Fork 1 बार + Lock 3 बार संरचना वाले सरल environment में SSD लागू किया गया
    • SSD के बाद सफलता संभावना बढ़ी, और optimal temperature range विस्तृत हुई
    • यह पुष्टि हुई कि training और decoding एक-दूसरे के पूरक हैं

  • वास्तविक मॉडल विश्लेषण

    • SSD के बाद शीर्ष tokens की cumulative probability बढ़ी, tail probability घटी
    • उच्च Teval पर भी प्रभावी शीर्ष candidates की संख्या बढ़ी, entropy बढ़ी
    • यानी SSD tail removal और शीर्ष distribution expansion दोनों एक साथ हासिल करता है

9. सैद्धांतिक विश्लेषण

  • SSD training loss को तीन terms में विभाजित किया जाता है
    1. Support Compression: tail probability हटाना
    2. Within-Support Reshaping: शीर्ष distribution का पुनर्गठन
    3. Alignment to Base Model: मूल मॉडल के साथ संरेखण बनाए रखना
  • Lock में पहला term प्रमुख होता है → tail removal
  • Fork में दूसरा term काम करता है → शीर्ष distribution का flattening
  • कुल entropy घटती है, लेकिन उपयोगी exploration entropy बनी रहती है
  • साधारण decoding adjustment ऐसा context-विशिष्ट पुनर्गठन नहीं कर सकता

10. असामान्य डेटा प्रयोग

  • Ttrain=2.0, बिना truncation से जनरेट किए गए डेटा का 62% अर्थहीन शोर (gibberish) था
  • इसके बावजूद SSD लागू होने के बाद
    • pass@1: 42.4% → 48.1% (+5.7pp)
    • pass@5: 53.5% → 64.0% (+10.5pp)
    • Hard समस्याओं में +7.3pp / +13.8pp सुधार
  • इससे पता चलता है कि SSD सही उत्तर की गुणवत्ता नहीं, बल्कि distribution structure सीखकर सुधार ला सकता है

निष्कर्ष

  • Simple Self-Distillation(SSD)
    • बाहरी teacher या verification के बिना सिर्फ मॉडल के अपने output से code generation प्रदर्शन सुधारता है
    • precision-exploration टकराव को कम करता है, और distribution reshaping के जरिए सामान्यीकृत सुधार हासिल करता है
  • SSD post-training चरण में लागू किया जा सकने वाला सरल लेकिन शक्तिशाली तरीका है, जो LLM code generation गुणवत्ता सुधारने के लिए एक व्यावहारिक विकल्प प्रस्तुत करता है

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

1 टिप्पणियां

 
GN⁺ 2026-04-05
Hacker News की राय

  • यह पेपर दिलचस्प इसलिए है क्योंकि इसने context-aware decoding की अवधारणा को वास्तव में लागू किया है
    यह समझाता है कि code generation के दौरान ‘fork’ points (रचनात्मक branching जहाँ कई व्याख्याएँ संभव होती हैं) और ‘lock’ points (सटीकता की ज़रूरत वाले syntactic decisions) बारी-बारी से आते हैं
    यह प्रभावशाली है कि SSD(Simple Self-Distillation) तकनीक दोनों स्थितियों में optimal tokens की ranking बेहतर बनाती है, जिससे model exploration के समय अधिक creative और accuracy की ज़रूरत होने पर अधिक precise तरीके से काम कर पाता है

    • सच कहूँ तो LLM की नई विशेषताओं की खोज मुझे चौंकाने वाली से ज़्यादा स्वाभाविक लगती है
      मानव मस्तिष्क पर भी हज़ारों साल से शोध हो रहा है, फिर भी उसके कई हिस्से अब भी अबूझ हैं
      यहाँ तक कि traffic flow के emergent behavior को भी हाल तक स्पष्ट रूप से नहीं समझा गया था
      इसलिए LLM की नई properties का लगातार सामने आना स्वाभाविक है
    • दिलचस्प बात यह है कि model ‘fork’ और ‘lock’ tokens दोनों पर समान मात्रा में computation खर्च करता है
      grammar-based sampling या grammar-aware decoding का उपयोग करने पर grammar के हिसाब से एकमात्र संभव token को model call के बिना सीधे insert भी किया जा सकता है
      लेकिन अभी व्यापक रूप से उपयोग होने वाले systems में यह लगभग लागू नहीं होता
      सोचने वाली बात है कि क्या ऐसा generalized approach संभव है जिसमें महत्वपूर्ण choices पर अधिक computation और स्पष्ट tokens पर कम computation लगाया जाए
    • छोटे model को fine-tune करते समय मुझे mode collapse की समस्या हुई थी, लेकिन training के दौरान field order को randomize करने से वह हल हो गई
      अब सोच रहा हूँ कि क्या inference के समय भी वही तरीका लागू करना चाहिए
    • दिलचस्प यह भी है कि SSD real time में temperature adjust किए बिना या fork/lock points का prediction किए बिना भी असरदार है
    • यह विचार सिर्फ code ही नहीं बल्कि अन्य generative content पर भी लागू हो सकता है
      code में बस इतना फर्क है कि उसकी structure अधिक स्पष्ट होती है, लेकिन fork/lock mechanism कई problem domains में काम आ सकता है

  • Self-Distillation LLM प्रगति की एक प्रमुख दिशा लगती है
    MIT और ETH टीम के Self-Distillation Fine-Tuning(SDFT) शोध ने पहले ही उच्च efficiency दिखाई थी
    इस पेपर का SSD(Simple Self-Distillation) असल में उसी का विस्तार जैसा है, बस नाम अलग है
    SSD नाम का SSD(solid-state drive) से टकराना भी भ्रम पैदा करता है
    अच्छा होता अगर मूल शोध SDFT को अधिक स्पष्ट रूप से credit और lineage दिया गया होता

  • हाल ही में मैंने Gemma 4 को local पर 50 tokens प्रति सेकंड की speed से चलते देखा
    यह पहले से ही Sonnet 3x~4 स्तर की क्षमता दिखा रहा है
    अगर इसमें SSD जैसी तकनीकें और जुड़ें, तो लगता है कि 2028 तक सस्ते और शक्तिशाली code models आम हो सकते हैं
    अनुभवी developers संभवतः अपने खुद के models को natural language को code में बदलने वाले non-deterministic transpiler की तरह चलाएँगे

    • मैं भी कभी-कभी यही सोचता हूँ। अगर model को केवल मेरी उपयोग की जाने वाली languages (PHP, SQL, JS आदि) के latest versions पर train किया जाए, तो क्या वह कहीं अधिक छोटा और तेज model नहीं बन सकता
      अभी तो यह कुछ वैसा लगता है जैसे ‘कीलों पर घर बनाना’
    • बेशक तब तक project-specific memory और on-demand learning वाले frontier models व्यक्तिगत models को पीछे भी छोड़ सकते हैं

  • SSD की मुख्य परिकल्पना, यानी precision–exploration tradeoff, उस समस्या से मिलती-जुलती है जिसे Adaptive Decoding हल करने की कोशिश करता है

    • मुझे भी Adaptive Decoding में काफी दिलचस्पी है
      inference के दौरान जिन क्षणों में creative thinking चाहिए वहाँ high temperature, और जहाँ syntactic accuracy चाहिए वहाँ low temperature की ज़रूरत होना काफी स्वाभाविक लगता है

  • सिर्फ बार-बार यह पूछने से कि “क्या यह सबसे elegant solution है?” LLM output में साफ़ सुधार दिखता है
    अगर model इतनी आसानी से बेहतर जवाब ढूँढ सकता है, तो सवाल उठता है कि उसने शुरुआत से ही ऐसा क्यों नहीं किया

    • वास्तव में elegant solutions ज़्यादातर पहली कोशिश में नहीं आते
      पहले कोई working solution बनाया जाता है, फिर उसे कई बार refine करने पर ही वह संक्षिप्त और साफ़ बनता है
    • मानव developers के साथ भी यही होता है
      कोई आधा दिन सोचने के बाद code लिखता है, तो कोई तुरंत पहला solution implement कर देता है
      मौजूदा LLM दूसरे प्रकार के ज़्यादा करीब हैं

  • यह शोध बेहतर code generation models की ओर ले जाने की काफी संभावना रखता है
    लेकिन हम अब भी ठीक से नहीं समझते कि high-dimensional space में क्या हो रहा है
    अंततः हम अभी भी ‘फेंको और देखो चिपकता है या नहीं’ वाले तरीके से explore कर रहे हैं

  • machine learning में breakthroughs ऊपर से देखने पर अक्सर सरल लगते हैं
    Transformer ऐसा ही था, और यह SSD भी वैसा ही है
    शायद इसलिए कि हमारे पास अभी तक गहरा सैद्धांतिक आधार नहीं है

    • सच तो यह है कि कई खोजों की तरह सरलता अक्सर सही होने का संकेत होती है
      जटिलता कई बार समझ की कमी का संकेत होती है
      मेरे programming अनुभव में यह काफी भरोसेमंद नियम रहा है

  • विडंबना यह है कि Apple अब भी AI research सार्वजनिक करता है, लेकिन OpenAI ऐसा नहीं करता

    • मुझे भी यह अजीब लगता है। इसे private रखने की कोई खास वजह नहीं दिखती
    • शायद OpenAI के पास अभी बचाने लायक ‘market’ ही नहीं है

  • किसी ने इस पेपर को “ऐसा model जिसे benchmark code results पर अच्छा दिखने के लिए fine-tune किया गया” कहकर संक्षेप में बताया, लेकिन असल में बात अलग है

    • पेपर देखने पर पता चलता है कि बिना answer verification या quality evaluation के, बस benchmark inputs दिए गए और generated outputs को फिर training में इस्तेमाल किया गया
      उसके बाद decoding settings (temp, top-k) समायोजित करने वाला model मूल model से बेहतर परिणाम देता है
      यानी यह सिर्फ benchmark के लिए किया गया fine-tuning नहीं, बल्कि self-output आधारित performance improvement है

  • इस शोध की तुलना golf practice से की जा सकती है
    हज़ारों बार गेंद मारकर basic swing को automated कर लेने के बाद, असली मैच में creative और risky shots को आत्मविश्वास से आज़माया जा सकता है
    SSD भी इसी तरह मूलभूत patterns को मज़बूत करके creative choices के लिए जगह बनाता है