भविष्य को आकार देने वाली तकनीक पर गहन लेख।

लूप्ड छोटे मॉडल: Production में बचने की 5 गलतियाँ

Looped transformers और NVFP4 quantization से छोटे मॉडल क्या कर सकते हैं, यह बदल गया है। Production में मॉडल चुनते समय ML practitioners की पाँच आम गलतियाँ।

एक छोटी पीतल की मशीन जटिल tapestry बुन रही है जो खुद के ऊपर से तीन बार गुज़रती है, looped model का प्रतीक।
छोटे का मतलब अब उथला नहीं रहा: बार-बार की internal passes compact मॉडलों को उनके parameter count से कहीं ऊपर प्रदर्शन करने देती हैं।

पिछले साल मैं जिस एक टीम को सलाह दे रहा था, वह हर महीने लगभग $4,000 सिर्फ़ एक frontier API पर सीधे-सादे ticket-triage prompts चलाने में खर्च कर रही थी। काम था classification और छोटे summary बनाना। इसे एक small language model ही एक GPU पर आराम से संभाल लेता, लेकिन टीम में किसी को यकीन नहीं था, क्योंकि पिछली बार जब उन्होंने 30B से छोटे किसी मॉडल को benchmark किया था, तो वह reasoning-heavy tasks में फेल हो गया था, और उसके बाद उन्होंने दोबारा देखा ही नहीं।

यह अंधा धब्बा अब तेज़ी से महंगा पड़ रहा है। Inkling 2 Mini — एक 26.4B-parameter open-weights mixture-of-experts मॉडल जो हर token के लिए अपनी बीच की layers को तीन बार loop करता है — का हालिया release agentic coding में 100B parameters से कम वाले हर open model से आगे निकल गया, और यह लगभग 20GB memory में फिट हो जाता है। एक ऐसा मॉडल जो laptop पर offline चलता है, SWE-bench-style tasks पर अपने से कई गुना बड़े मॉडलों से बेहतर साबित हुआ है। 'छोटा' और 'सक्षम' के बीच का फासला इतना कम हो गया है कि model sizing को लेकर practitioners के मन में बैठे ज़्यादातर नियम अब पुराने पड़ चुके हैं। यहाँ वे पाँच गलतियाँ हैं जो मैं सबसे ज़्यादा देखता हूँ, और उनके बजाय क्या करना चाहिए।

गलती 1: Parameter Count को Capability की ऊपरी सीमा मानना

ज़्यादातर लोगों के दिमाग में जो मॉडल बैठा है वह सीधा है: parameters बजट हैं, और capability उसी बजट के हिसाब से बढ़ती है। यह पूरी तरह कभी सही नहीं था — training data और compute का भी बहुत असर होता है — लेकिन जब तक architecture असली काम नहीं करने लगा था, तब तक यह एक काम का heuristic था। Looping इसका सबसे साफ़ उदाहरण है। Inkling 2 Mini अपनी बीच की 12 layers (कुल 24 में से छह-छह की दो blocks) को हर token के लिए तीन बार चलाता है, जबकि पहली और आखिरी block एक बार चलती हैं। विचार यह है: शुरुआती और आखिरी layers ज़्यादातर embeddings और internal representations के बीच अनुवाद करती हैं, जबकि बीच की layers abstract reasoning उठाती हैं। यानी compute वहीं खर्च होता है जहाँ reasoning होती है।

प्रकाशित ablation पर ध्यान देने लायक है: बीच की 12 layers को loop करना आखिरी 12 को loop करने से 28 में से 27 evaluations में बेहतर रहा, और बिना loop वाले baseline को middle-loop मॉडल के loss तक पहुँचने के लिए अनुमानित 1.5–1.9 गुना ज़्यादा compute चाहिए था। यह कोई मामूली tuning trick नहीं है। यह compute allocation की एक अलग रणनीति है, और यह parameter-count वाले सीधे heuristic को एक खास, अनुमान योग्य दिशा में तोड़ देती है।

उपाय: जब आप किसी छोटे मॉडल का मूल्यांकन करें, तो पूछें कि प्रति token compute कहाँ जा रहा है, सिर्फ़ यह नहीं कि कितने weights हैं। 3.4B active parameters और looped बीच की layers वाला 26B मॉडल "एक छोटा मॉडल जो लंबा सोचता है" के ज़्यादा करीब है, न कि सिर्फ़ "एक छोटा मॉडल"। यह उस बात से जुड़ता है जो मैं पहले भी कह चुका हूँ: reasoning मॉडलों में training से आता है, prompt से नहीं निकाला जाता — और अब यह धीरे-धीरे architecture में भी डाला जा रहा है।

गलती 2: Reasoning और Knowledge को एक समझ लेना

Looped-model की कहानी का वह हिस्सा जिसे practitioners लगातार छोड़ देते हैं, और यही आपको काटेगा। Looping reasoning सुधारता है। यह knowledge नहीं बनाता। तथ्य weights में रहते हैं, और weights की संख्या जितनी है उतनी ही रहती है। Inkling 2 Mini की टीम इस पर काफ़ी साफ़गोई से बात करती है: factuality benchmark AA-Omniscience पर यह मॉडल अपने आकार के दूसरे मॉडलों के बराबर स्कोर करता है। उनका variable-loop research variant loops बढ़ाने पर serial-reasoning और long-context benchmarks में सुधार दिखाता है — दस loops तक, यानी प्रशिक्षण के दोगुने तक — लेकिन SimpleQA जैसे knowledge-intensive benchmarks उन अतिरिक्त passes से ज़रा भी नहीं हिले।

मैंने एक दोस्त को production में ठीक इसी भ्रम को debug करते देखा है। उन्होंने support-bot workload पर एक बड़े मॉडल की जगह एक छोटा reasoning-forward मॉडल लगाया, reasoning की गुणवत्ता में उछाल देखी और ship कर दिया। दो हफ़्ते बाद: hallucinated product SKUs, गढ़े हुए policy details। मॉडल उन तथ्यों के बारे में बहुत सुंदर reasoning कर रहा था जो उसमें थे ही नहीं। एक शुरुआती Hacker News tester दो prompts के भीतर इसी दीवार से टकराया — एक WordPress plugin माँगी जो obscure API कोनों को छूती हो, और जवाब में आत्मविश्वास भरा, अच्छी तरह संरचित, लेकिन गलत code आया।

समाधान "बड़ा मॉडल इस्तेमाल करो" नहीं है। यह architectural है: छोटे reasoner को retrieval और tools के साथ जोड़ें। खास बात यह है कि Inkling 2 Mini BrowseComp और DeepSearchQA पर तुलनीय open models से आगे है — ये benchmarks search और tool use को मापते हैं। अच्छे tool hygiene वाला छोटा मॉडल अक्सर उस बड़े मॉडल को हरा देता है जो पुराने तथ्य याद करता है, क्योंकि retrieved context ताज़ा और audit करने योग्य होता है। मेरा नियम: अगर आपके workload की विफलताएँ reasoning की विफलताएँ हैं, तो looped छोटा मॉडल मदद करेगा। अगर वे knowledge की विफलताएँ हैं, तो parameter count नहीं, अपना retrieval ठीक करें।

गलती 3: Low-Bit Quantization को सिरे से खारिज करना

पाँच साल पहले, "हमने इसे 4-bit में quantize किया" एक माफ़ीनामे जैसा था। छोटे hardware पर फिट होने के बदले आप असली गुणवत्ता की कीमत चुकाते थे, और 4-bit से नीचे जाना एक science project था। यह धारणा अब लोगों के असली hardware budget पर भारी पड़ रही है। Inkling 2 Mini को शुरू से अंत तक NVFP4 में train किया गया है और यह NVFP4 में ही native रूप से deploy होता है, सिर्फ़ आखिरी चार layers MXFP8 में हैं — quantization कोई post-hoc compression step नहीं, बल्कि training recipe का हिस्सा है। नतीजा: लगभग 20GB का footprint, और BF16 के समकक्ष मॉडलों जैसी गुणवत्ता।

बड़ी घनी किताबें एक छोटे, चमकते पतले खंडों के सेट में सिमट गई हैं, quantization-aware training का प्रतीक।
Quantization-aware training का मतलब है कि छोटा footprint कोई समझौता नहीं, बल्कि पहले दिन से डिज़ाइन का लक्ष्य है।

इसका downstream असर चौंकाने वाला है। Unsloth टीम — जो quantization की तकलीफ़ किसी से बेहतर जानती है — ने देखा कि ये स्वाभाविक रूप से low-bit मॉडल आगे की quantization पर असामान्य रूप से अच्छी प्रतिक्रिया देते हैं, और 1-bit पर भी लगभग 90% top-1 agreement बनाए रखते हैं। रिलीज़ के कुछ ही दिनों में Hugging Face पर एक GGUF build आ गया, और practitioners इसे पहले से ही MacBook Pro पर हवाई जहाज़ में चला रहे हैं (टीम ने उड़ान के बीच offline में एक playable flight simulator बनाकर इसका डेमो भी दिखाया) और 7900XTX जैसे consumer GPUs पर भी।

उपाय: quantization को degradation मानना बंद करें और पूछें कि क्या मॉडल प्रशिक्षित ही low precision पर हुआ था। अगर हाँ, तो 4-bit (या उससे कम) artifact पहली श्रेणी का नागरिक है, और आपका "हमें 80GB VRAM चाहिए" वाला sizing हिसाब दोबारा करना होगा। अगर आप देख रहे हैं कि यह offline deployments के लिए क्या खोलता है, तो architectural patterns हमने ऐसा LLM बनाना जो offline काम करे में और hardware वाला पहलू अपने hardware पर LLMs चलाना में कवर किया है।

गलती 4: एक बार benchmark करके अपनी model choice को फ्रीज़ कर देना

सबसे महंगी गलती तकनीकी नहीं, प्रक्रियात्मक है। टीमें किसी feature को बनाते समय एक बार bake-off करती हैं, एक मॉडल चुनती हैं, और उस फ़ैसले को स्थायी मान लेती हैं। लेकिन प्रति parameter capability का frontier procurement cycles से कहीं तेज़ी से आगे बढ़ रहा है। Inkling 2 Mini ने DeepSWE v1.1 पर 48.2% और Vals Index v2.2 पर 46.5% स्कोर किया — 100B कुल parameters से कम वाले हर open-weights मॉडल से आगे — और यह ऐसे समय में हुआ जब यह समतुल्य प्रदर्शन वाले मॉडलों से तेज़ decode कर रहा था, क्योंकि 3.4B active parameters वाला MoE, 27B dense मॉडल की तुलना में प्रति token कहीं कम weights पढ़ता है। नौ महीने पहले लिया गया model choice अब कोई फ़ैसला नहीं रहा; वह बिना जाँचा हुआ एक आदत है।

लेकिन सीधे-सीधे दोबारा benchmark करना भी अपना जाल है। Public leaderboards वह मापते हैं जो benchmark लेखकों को दिलचस्प लगा, न कि आपका product क्या करता है। यही AI benchmarks असली काम का ज़्यादातर हिस्सा क्यों छोड़ देते हैं वाली core समस्या है, और छोटे मॉडलों में यह और बदतर होती है क्योंकि उनकी प्रोफ़ाइल ज़्यादा ऊबड़-खाबड़ होती है: Inkling 2 Mini agentic coding में सर्वश्रेष्ठ है, फिर भी MultiChallenge पर औसत 50.0% और ComplexConstraints पर 33.4% स्कोर करता है — दोनों पर Qwen3.8-27B से पीछे। अगर आपका workload constraint-heavy multi-turn chat है, तो coding के मुख्य आँकड़े आपके लिए बेकार हैं।

उपाय: अपने production traffic से बना एक छोटा, versioned eval suite रखें — ज्ञात सही आउटपुट वाले 200 से 500 असली cases — और हर तिमाही नए model releases को उस पर चलाएँ। यह लगता है उससे सस्ता है और दोनों तरह के आश्चर्य पकड़ता है: ऐसे मॉडल जो benchmarks के सुझाव से बेहतर निकलते हैं (एक commenter ने लिखा कि Inkling 2 Small "benchmarks के सुझाव से बेहतर लगा") और ऐसे मॉडल जो leaderboards पर चमकते हैं लेकिन आपके constraint-heavy prompts पर फेल होते हैं। हर तिमाही एक दिन लगाएँ। पहली बार जब यह आपको एक model tier नीचे उतरने देगा, तो यह अपनी लागत खुद वसूल लेगा।

गलती 5: Ledger के cost वाले पक्ष को नज़रअंदाज़ करना

Model selection की बातचीत accuracy पर अटक जाती है और cost को बाद की सोच मान लेती है। Production में यह उलटा है, जहाँ cost curve ही तय करता है कि क्या संभव है। Stanford की Hazy Research Lab ने Inkling 2 Mini पर शुरुआती intelligence-per-joule मापन किए और 0.703 पाया — जबकि Qwen3.6-35B-A3B के लिए 0.430, Gemma-4-26B-A4B के लिए 0.159, और Qwen3.5-27B के लिए 0.036। यह कुछ प्रतिशत बेहतर होना नहीं है; यह एक अलग दुनिया है। और यह जुड़ता चला जाता है: जो मॉडल कम tokens में उत्तर तक पहुँचता है (looping का पूरा दावा यही है कि reasoning को लिखे बिना करना) वह प्रति task compute और latency दोनों पर कम खर्च करता है।

जो व्यावहारिक नतीजा मुझे सबसे ज़्यादा रोमांचित करता है वह है multi-agent density। चूँकि यह एक छोटा MoE है, आप एक ही GPU की VRAM में कई agents के KV caches फिट कर सकते हैं — एक offline MacBook से चल रहे 20 simulated गाँव वालों का डेमो मज़ेदार है, लेकिन गंभीर संस्करण है एक DGX Spark या एक workstation पर एक दर्जन production agents, न कि per-token billing और data egress वाले API calls का बेड़ा। इस tier की ओर व्यापक बदलाव पर हमने flash-tier LLMs ही असली inference efficiency कहानी क्यों हैं में लिखा है, और looped छोटे मॉडल उस तर्क को काफ़ी धार देते हैं।

उपाय: अपना cost model प्रति पूरे हुए task की लागत पर बनाएँ, प्रति token पर नहीं। Looping प्रति token wall-clock time बढ़ाता है (बीच की layers तीन बार चलती हैं, और memory bandwidth का हिसाब बार-बार पढ़ने से बढ़ता है), इसलिए सीधे tokens-per-second की तुलना दोनों दिशाओं में भ्रामक हो सकती है। End-to-end मापें: task हल हुआ या नहीं, कितने tokens लगे, कितनी ऊर्जा और latency खर्च हुई। जो मॉडल प्रति token 20% धीमा है लेकिन आधे tokens में और कम retries के साथ हल कर देता है, वह हर बार जीतता है।

एक छोटा दीया चमकते घरों वाले एक छोटे गाँव को रोशन कर रहा है, एक ही डिवाइस पर कई agents का प्रतीक।
एक कुशल छोटा मॉडल एक ही मशीन पर agents के पूरे बेड़े को चला सकता है — कोई API meter नहीं चलता।

सोमवार को असल में क्या करें

  1. अपने API खर्च को task type के हिसाब से audit करें। Classification, extraction, routing, या छोटे agentic loops वाला कोई भी काम sub-30B local मॉडल का उम्मीदवार है। उसकी कीमत निकालें।
  2. अपने eval suite को reasoning विफलताओं और knowledge विफलताओं में बाँटें। Looped छोटे मॉडल पहली को ठीक करते हैं। Retrieval दूसरी को। दोनों को मिलाएँ नहीं।
  3. जाँचें कि आपका candidate मॉडल low precision पर प्रशिक्षित हुआ था या नहीं। अगर हाँ, तो 4-bit artifact को आखिर में नहीं, पहले टेस्ट करें — वही उसका native रूप है।
  4. हर तिमाही अपने traffic पर benchmark करें। Public scores एक screening tool हैं, फ़ैसला नहीं।
  5. एक multi-agent workload को local hardware पर prototype करें। जब कोई per-token meter नहीं चलता, तो persistent agents का अर्थशास्त्र पूरी तरह बदल जाता है।

इसमें बड़ा बदलाव किसी एक मॉडल का नहीं है। यह है कि frontier labs की research दिशाएँ — looping, quantization-aware training, expert pruning के साथ healing — अब महीनों के भीतर open weights में उतर रही हैं, और उन्हीं hardware के लिए बनी हैं जो आपके पास पहले से है। अगले कुछ सालों में जीतने वाले practitioners वे नहीं होंगे जिनके API बजट सबसे बड़े हैं। वे होंगे जो अपनी model धारणाओं को एक नियमित समय-सारणी पर दोबारा परखते हैं, क्योंकि इन धारणाओं की उम्र कोड से भी छोटी होती है।

एक छोटा मॉडल जो अच्छा reason करता है और ईमानदारी से retrieve करता है, वह एक बड़े मॉडल को हरा देता है जो आत्मविश्वास से याद रखता है और आलस्य से reason करता है — लागत में, latency में, और अक्सर accuracy में भी।