वेट-स्पेस प्रोग्रामिंग: LLM के लिए तीसरा लीवर

ग्रेडिएंट डिसेंट कभी पवित्र नहीं था। वह एक अस्थायी ढाँचा (scaffolding) था — अरबों ऐसी संख्याओं को आकार देने का एकमात्र सामान्य-उद्देश्य तरीका, जिन्हें कोई इंसान पढ़ नहीं सकता, इसलिए हमने पूरे डीप लर्निंग का तंत्र उसी के इर्द-गिर्द बना लिया। MIT CSAIL की एक टीम ने अभी इस ढाँचे को चुनौती दी है। उन्होंने एक फ्रंटियर मॉडल को प्रशिक्षित न्यूरल नेटवर्क के कच्चे वेट्स दिए और सादी भाषा में पूछा कि उन्हें समझाओ, डीबग करो और दोबारा लिखो — न कोई ट्रेनिंग लूप, न ग्रेडिएंट, न फॉरवर्ड पास। और यह काम कर गया। वेट-स्पेस प्रोग्रामिंग, यानी पैरामीटर्स के बारे में सीधे तर्क करना, न कि उन्हें ढलान की ओर धक्का देना, अब एक विचार-प्रयोग से निकलकर डेमो तक पहुँच गई है। और मुझे लगता है कि इससे फ़ाइन-ट्यूनिंग चुपचाप "मॉडल को अनुकूलित करने का तरीका" से घटकर तीन विकल्पों में से बस एक रह जाती है।

मुख्य नतीजा अपनी मिली हुई चर्चा का हक़दार है। Qwen3.5-0.8B को बिना किसी ग्रेडिएंट अपडेट के गणित में बेहतर बनाने के लिए कहा गया, और मॉडल — GPT-6 Astra — ने एक समस्यात्मक रीजनिंग लूप को दो MLP लेयर्स में लिखी एक एकल दिशा तक ट्रेस किया, उसे 0.016% वेट्स में से घटा दिया, और MATH-500 की सटीकता 7.9% से 48.1% तक पहुँच गई। वही सैंपलिंग सेटिंग्स, सब कुछ वही। यह सुधार instruction following में भी लागू हुआ और IFEval को तीन गुना कर दिया। यह कोई हाइपरपैरामीटर ट्वीक नहीं है; यह सर्जरी है। लेकिन ग्रेडिएंट डिसेंट को दफ़नाने से पहले यह समझना ज़रूरी है कि असल में क्या दिखाया गया, यह कहाँ तक सामान्यीकृत होता है, और कहाँ पहले ही विफल हो जाता है।

वेट-स्पेस प्रोग्रामिंग असल में क्या है

सालों से मॉडल का व्यवहार बदलने के हमारे पास ठीक दो तरीके थे। प्रॉम्प्टिंग इनपुट बदलती है; वेट्स जमे रहते हैं। फ़ाइन-ट्यूनिंग वेट्स बदलती है, लेकिन अंधाधुंध — आप लॉस लैंडस्केप को उदाहरणों का एक बैच दिखाते हैं और ग्रेडिएंट्स को पैरामीटर्स को उस दिशा में धकेलने देते हैं जो त्रुटि घटाए, इस पर लगभग कोई नियंत्रण नहीं होता कि रास्ते में कौन सी आंतरिक मशीनरी फिर से जुड़ जाएगी। वेट-स्पेस प्रोग्रामिंग एक तीसरा लीवर प्रस्तावित करती है: लॉस फंक्शन को पूरी तरह हटा दो, और एक रीजनिंग सिस्टम को वेट्स पढ़ने दो, यह अनुमान लगाने दो कि वे क्या गणना करते हैं, और फिर उन्हें सादी भाषा के स्पेक के अनुसार संपादित करने दो।

पढ़ने वाले नतीजे सबसे अजीब हिस्सा हैं। शोधकर्ताओं ने चार छोटी पॉलिसीज़ को PPO से प्रशिक्षित किया ताकि वे ग्रिड-वर्ल्ड वर्ज़न्स में Breakout, Pong, Pac-Man और Freeway खेल सकें — एक जैसी आर्किटेक्चर, एक जैसे इनपुट चैनल, एक जैसे एक्शन स्पेस, यानी सिर्फ़ वेट्स ही उन्हें अलग कर सकते थे। Astra ने बिना उम्मीदवारों की सूची बताए चारों खेलों के नाम सही बताए। यही उसने उन डिफ्यूज़न मॉडल्स के साथ किया जो वृत्त, वर्ग और त्रिभुज बनाने के लिए प्रशिक्षित थे, और — जो कठिन संस्करण था — तीन कैरेक्टर-लेवल ट्रांसफ़ॉर्मर्स में से यह पहचाना कि कौन सा Python, अंग्रेज़ी या रोमनीकृत जापानी पर प्रशिक्षित था, केवल बीच की लेयर्स दिए जाने पर, जिसमें एम्बेडिंग और आउटपुट लेयर्स हटा दी गई थीं और हर डायमेंशन अनलेबल्ड था। इस दौरान उसने हर इंडक्शन हेड भी खोज निकाला — वे कॉपी करने वाले सर्किट जो मॉडल को पहले के टेक्स्ट को दोहराने देते हैं — वेट मैट्रिसेस को आपस में गुणा करके। यह इंटरप्रेटेबिलिटी साहित्य की एक ज्ञात तकनीक है, जिसके बारे में किसी ने उसे बताया भी नहीं था। अगर आपने मैकेनिस्टिक इंटरप्रेटेबिलिटी के धीमे, मेहनती काम को फॉलो किया है, तो एक सामान्य-उद्देश्य मॉडल को यह सब स्वाभाविक रूप से करते देखना थोड़ा चक्कर ला देने वाला है।

फिर उसने वेट्स लिखे। एक PPO-प्रशिक्षित कार कंट्रोलर, जो लोकल मिनिमम में फँसा था — पॉलिसी सीधे रैंप की ओर चली जा रही थी, बजाय पहले पीछे हटकर स्पीड बनाने के — Astra ने वेट्स और एक रिकॉर्ड की गई एपिसोड से विफलता का निदान किया, और उसके एडिट ने 3.5% पैरामीटर बदलकर कार को सभी 1,024 मूल्यांकन एपिसोड्स में सफल बना दिया। जब उससे बिना किसी एनवायरनमेंट फ़ीडबैक के, शून्य से गेम-प्लेइंग नेटवर्क लिखने को कहा गया, तो उसने ऐसी पॉलिसीज़ बनाईं जिन्होंने उन नेटवर्क्स को हराया जिन्हें PPO ने 100 मिलियन स्टेप्स तक प्रशिक्षित किया था। इसे दोबारा पढ़िए: कोई इंटरैक्शन नहीं, कोई रिवॉर्ड सिग्नल नहीं, बस एक गेम का सादी भाषा में वर्णन, जिसे एक भाषा मॉडल के रीजनिंग ने काम करने वाले वेट्स में बदल दिया।

असली मॉडलों पर डायरेक्ट वेट एडिट कैसे काम करते हैं

Qwen वाला सुधार प्रैक्टिशनर्स के लिए सबसे अहम नतीजा है, क्योंकि 0.8 अरब पैरामीटर एक असली मॉडल है — ऐसा जिसे टीमें वाकई फ़ाइन-ट्यून करके शिप करती हैं। यह विफलता अच्छी तरह दस्तावेज़ित है: छोटे रीजनिंग मॉडल लूप में फँस जाते हैं, वही टेक्स्ट दोहराते रहते हैं जब तक टोकन की सीमा न आ जाए, बिना कोई उत्तर दिए। Qwen का अपना मॉडल कार्ड इसके बारे में चेतावनी देता है, और शोधकर्ताओं के अभ्यास रनों में पहले 96 उत्तरों में से 85 इसी तरह पूरे 32,768-टोकन कॉन्टेक्स्ट को खा गए। Astra का निदान: लेयर 15 और 19 के MLPs रेज़िड्युअल स्ट्रीम में एक ऐसी दिशा लिख रहे थे जो मॉडल को बार-बार उसी जनरेटिव ट्रैजेक्टरी में खींच रही थी। उसका सुधार था, उन दोनों MLPs के हर 64 आउटपुट कॉलम्स से वह दिशा घटाना — कुल 131,072 वेट्स, यानी मॉडल का 0.016%।

गणित लगभग अपमानजनक रूप से सरल है, और यही बात है। एक बार यह पता चल जाए कि एक्टिवेशन स्पेस की कौन सी दिशा "हमेशा लूप करो" से मेल खाती है, तो उसे हटाना एक प्रोजेक्शन है: हर प्रभावित वेट वेक्टर के लिए, उसके बुरी दिशा के साथ वाले घटक को घटा दो। इसे कोई भी एक दर्जन लाइनों में लिख सकता है।

import numpy as np
def subtract_direction(W, v, columns):
"""Remove the component of each chosen column that lies along v."""
v = v / np.linalg.norm(v)
W[:, columns] -= np.outer(v, v @ W[:, columns])
return W
# The Qwen repair, schematically: for the MLP output projections of
# layers 15 and 19, subtract the "loop" direction from 64 columns each.
# 2 layers x 64 columns x 1024 rows = 131,072 edited weights.
W_down[15] = subtract_direction(W_down[15], loop_dir[15], cols[15])
W_down[19] = subtract_direction(W_down[19], loop_dir[19], cols[19])

कठिन हिस्सा कभी घटाना नहीं था — कठिन है यह जानना कि कौन सी दिशा, किस लेयर में, हज़ारों डायमेंशन चौड़ी रेज़िड्युअल स्ट्रीम में। यही वह हिस्सा है जिसके लिए पहले हमें ग्रेडिएंट डिसेंट की ज़रूरत थी, क्योंकि ग्रेडिएंट्स वेट स्पेस में एक खोज प्रक्रिया हैं जिसके लिए किसी समझ की ज़रूरत नहीं होती। Astra ने खोज की जगह निदान रख दिया। यह उस इलेक्ट्रीशियन और उस व्यक्ति के बीच का फ़र्क है जो तब तक सर्किट के तार बदलता रहता है जब तक खराबी न हटे, और उस व्यक्ति के बीच का जो स्कीमैटिक पढ़कर सही तार काट देता है। इसी तर्क से मॉडल ने वेट मैट्रिसेस को जोड़कर इंडक्शन हेड्स खोजे: उसने एक प्रकाशित इंटरप्रेटेबिलिटी मेथड लागू किया जो उसे कभी दिखाया नहीं गया था, जो याद की हुई रेसिपी नहीं बल्कि तर्क के वास्तविक ट्रांसफ़र की ओर इशारा करता है।

जब डायरेक्ट वेट एडिटिंग फ़ाइन-ट्यूनिंग से बेहतर होती है

यह मेरी राय है, और मैं इसका बचाव करूँगा: छोटे-से-मध्यम आकार के मॉडलों में संकीर्ण, स्थानीयकृत विफलताओं के लिए डायरेक्ट वेट एडिटिंग पहले से ही बेहतर उपकरण है, और इसमें कोई तुलना नहीं। लूप वाले बग के लिए फ़ाइन-ट्यूनिंग विकल्प पर विचार कीजिए। आपको गैर-लूपिंग रीजनिंग ट्रेसेस का डेटासेट बनाना होगा, SFT या RL चलाना होगा, और उम्मीद करनी होगी कि लॉस का दबाव बाकी ज्ञान को बिगाड़े बिना व्यवहार हटा दे। आप GPU-घंटे उस प्रॉक्सी की ओर हिल-क्लाइम्बिंग में जला देंगे — ज़्यादा गणित डेटा — बजाय उस असली इरादे के, जो है "अपने आप को दोहराना बंद करो।" वेट-स्पेस प्रोग्रामिंग आपको इरादा बताने देती है। एडिट ने मॉडल के सौवें हिस्से से भी कम को छुआ; फ़ाइन-ट्यून पूरे मॉडल को छूती है, और उसका नुकसान बाद में अजीब रिग्रेशन के रूप में सामने आता है, जिसे कोई ट्रेनिंग रन से नहीं जोड़ पाता।

फ़ाइन-ट्यूनिंग आपके इरादे के प्रॉक्सी की ओर हिल-क्लाइम्ब करती है। वेट-स्पेस प्रोग्रामिंग आपको इरादा बताने देती है।

दूसरा मामला उन लोकल मिनिमा से निकलना है जिन्हें ग्रेडिएंट मेथड्स संरचनात्मक रूप से छोड़ नहीं सकते। PPO ने कार को रैंप के सामने फँसा दिया, क्योंकि रीइन्फोर्समेंट लर्निंग मौजूदा पॉलिसी को हल्का-सा हिलाकर एक्सप्लोर करती है, और "सीधे चलो" में कोई छोटी सी गड़बड़ी "पहले दो सेकंड पीछे जाओ" तक नहीं पहुँचती। रीजनिंग हिलती नहीं। वह समस्या के मॉडल पर काम करती है, न कि मौजूदा उत्तर के किसी परटर्बेशन पर, इसलिए वह गुणात्मक रूप से अलग समाधान पर छलांग लगा सकती है। एक अरब PPO स्टेप्स वह नहीं खोज पाए जो एक रीजनिंग पास ने खोज लिया — यह कार्यकुशलता का अंतर नहीं, श्रेणी का अंतर है।

तीसरा, इटरेशन लूप सिकुड़ जाता है। फ़ाइन-ट्यूनिंग की एक लॉजिस्टिक्स पूँछ है — डेटा क्यूरेशन, ट्रेनिंग रन, इवल स्वीप, रिग्रेशन चेक — जो "छोटे व्यवहार परिवर्तन" को कई दिनों के प्रोजेक्ट में बदल देती है। जिसने भी बड़े मॉडल को अपने हार्डवेयर पर चलाया है, वह जानता है कि मेहनत का कितना हिस्सा मॉडलिंग के बजाय प्लंबिंग में जाता है। वेट एडिट कोड हॉटफ़िक्स के ज़्यादा करीब है: निदान करो, पैच लगाओ, इवल चलाओ, गलत हो तो वापस लो। जब निदान सही हो, तो आप पूरी ट्रेनिंग पाइपलाइन छोड़ देते हैं। स्पष्ट जीत चार स्थितियों में मिलती है:

• विफलता का निदान हो गया है, लेकिन आपके पास ऐसा कोई ट्रेनिंग डेटा नहीं है जो सुधार को व्यक्त करे
• आपको सर्जिकल दायरा चाहिए — एक व्यवहार बदलें बिना बाकी को बिगाड़े
• मॉडल एक लोकल मिनिमम में फँसा है, जहाँ रैंडम एक्सप्लोरेशन से निकलना संभव नहीं
• आप ट्रेनिंग पाइपलाइन का खर्च नहीं उठा सकते, न GPU में, न कैलेंडर के समय में

वेट-स्पेस प्रोग्रामिंग इतनी नाज़ुक क्यों है

अब ठंडा पानी, क्योंकि उसकी भी कमी नहीं है। सबसे उपयोगी डेटा पॉइंट जो मैंने देखा है वह पेपर से नहीं, बल्कि एक प्रैक्टिशनर से आया है, जिसने वही ट्रिक एक छोटे natural-language-to-bash मॉडल पर आज़माई और कुल मिलाकर कुछ हासिल नहीं हुआ। 1,920 वेट्स एडिट करने से कुछ grep की गलतियाँ ठीक हुईं और दूसरे कमांड टूट गए। यह अपेक्षित नतीजा है, और यही गहरी समस्या है: प्रशिक्षित नेटवर्क्स में व्यवहार आपस में उलझे होते हैं। Qwen का एडिट इसलिए काम किया क्योंकि लूप वाला व्यवहार संयोग से एक छोटी, हटाई जा सकने वाली दिशा में रहता था। कई व्यवहार ऐसे नहीं होते। वे सुपरपोज़िशन में फैले होते हैं, जहाँ वही कॉलम कई असंबंधित फ़ीचर्स ढोते हैं, इसलिए एक "दिशा" घटाना एक कॉर्ड से एक नोट हटाने जैसा है। दूसरे नोट्स भी कटेंगे। अभी तक कोई सिद्धांत नहीं है जो पहले से बता सके कि कौन सी विफलता ज्यामितीय रूप से संक्षिप्त है और कौन सी फैली हुई — जब तक यह न हो, हर वेट एडिट एक जुआ है।

प्रदर्शनों पर भी थोड़ा संदेह करना चाहिए। गेम नेटवर्क्स पर Astra का तर्क सतही सांख्यिकी पर टिका था — फ़र्स्ट-लेयर वेट्स कहाँ केंद्रित हैं, कौन से आउटपुट लॉजिट्स अलग होते हैं — और भाषा पहचान असल में तीन विकल्पों वाला बहुविकल्पीय प्रश्न था, जिसमें एक विकल्प, रोमनीकृत जापानी, में अक्षरों का असामान्य वितरण साफ़ दिखता है (q, l, v या x नहीं)। प्रभावशाली पैटर्न-मैचिंग? बिल्कुल। वेट स्पेस की गहरी मूल समझ का सबूत? यह कम साफ़ है। डिफ्यूज़न वाला नतीजा दोनों तरफ़ जाता है: Astra ने हर आकृति को बाहरी रेखा के रूप में बनाया, जबकि मॉडल असल में भरी हुई आकृतियाँ बनाते हैं — यह गलती साबित करती है कि उसने नेटवर्क का अनुकरण करने के बजाय ज्यामिति पढ़ी, लेकिन यह भी दिखाती है कि उसकी "समझ" संरचनात्मक रूप से गलत हो सकती है और फिर भी टेस्ट पास कर सकती है।

फिर पैमाने और उत्पत्ति का सवाल है। हर साफ़ नतीजा 17,000 से 70 लाख वेट्स के बीच है, जिसमें Qwen का 0.8B अपवाद है, और यहाँ तक कि बीच की लेयर्स वाला रीडिंग प्रयोग भी वहाँ तक पहुँचने के लिए सौ तक Python विश्लेषण रनों का मोहताज था। किसी ने 70B मॉडल पर भी यह काम करते नहीं दिखाया, फ़्रंटियर मॉडल की तो बात ही छोड़िए, और सरल तरीका — वेट्स को कॉन्टेक्स्ट विंडो में चिपकाना — उससे बहुत पहले ही दम तोड़ देता है। एक असहज सवाल भी पूरे मामले पर मंडराता है: यह क्षमता आई कहाँ से? जो LLMs शतरंज में संदिग्ध रूप से अच्छे हैं, वे आमतौर पर ट्रेनिंग में बहुत सारी शतरंज नोटेशन खा चुके होते हैं। अगर Astra को जानबूझकर वेट डेटा पर प्रशिक्षित किया गया था, तो ये नतीजे उभरती समझ के बारे में कम और एक बहुत अच्छे करिकुलम के बारे में ज़्यादा बताते हैं। हम सच में नहीं जानते।

अंत में, MATH-500 की छलांग पर एक शर्त लगानी होगी। यह बेंचमार्क सालों से ट्रेनिंग डेटा से संतृप्त हो चुका है, और 7.9% स्कोर करने वाला बेस मॉडल लगभग निश्चित रूप से लूपिंग और फ़ॉर्मेटिंग में विफल हो रहा है, न कि गणित की क्षमता में — यानी एडिट ने नई क्षमता बनाने के बजाय छिपी हुई क्षमता को अनब्लॉक किया। फिर भी यह मूल्यवान है; अनब्लॉक करना असली जीत है। लेकिन यह "एडिट ने मॉडल को गणित में बेहतर बनाया" से अलग दावा है, और यह एक परिचित पैटर्न में फ़िट बैठता है जहाँ बेंचमार्क असली काम के ज़्यादातर हिस्से को छूट जाते हैं।

प्रोडक्शन में वेट एडिट्स: इन्हें हॉटफ़िक्स की तरह बरतें

अगर आप इसे आज़माना चाहते हैं — और छोटे मॉडलों पर, आपको आज़माना चाहिए — तो वेट एडिट्स से उसी अनुशासन से पेश आइए जैसे आप चलते डेटाबेस पर हॉट पैच से आते। हर चीज़ का डिफ़ लीजिए: ठीक-ठीक बताइए कि कौन से टेंसर बदले और कितना, क्योंकि 0.016% इतना छोटा है कि आपकी एडिट स्क्रिप्ट का चुपचाप रहने वाला बग हमेशा छिपा रह सकता है। व्यापक रूप से मूल्यांकन कीजिए, सिर्फ़ लक्ष्य व्यवहार पर नहीं; Qwen का सुधार संयोग से इंस्ट्रक्शन फ़ॉलोइंग को भी बेहतर कर गया, लेकिन उस साइड इफ़ेक्ट की दिशा किस्मत थी, और अगली बार उल्टी जा सकती है। बेस चेकपॉइंट को पवित्र रखिए और हर एडिट को एक उलटे जा सकने वाले पैच के रूप में वर्ज़न कीजिए। और अपनी महत्वाकांक्षा सीमित रखिए: प्रदर्शित मीठा स्थान छोटी, अच्छी तरह समझी गई विफलताएँ हैं, जिन्हें आप पूरी तरह मूल्यांकित कर सकते हैं। अगर आपका मन किसी 70B मॉडल की धुंधली "वाइब" वाली समस्या को "खराब दिशा हटाकर" ठीक करने का है, तो आप सुपरपोज़िशन के बारे में कठिन तरीके से सीखने वाले हैं।

• बेस चेकपॉइंट पिन करें; एडिट्स को डिफ़ के रूप में सहेजें, कभी सीधे ओवरराइट न करें
• लक्ष्य बेंचमार्क के अलावा, पहले और बाद में व्यापक इवल चलाएँ
• धुंधले "वाइब" के बजाय तीखे, दोहराए जा सकने वाले लक्षण वाली विफलताएँ चुनें
• रिवर्ट के लिए बजट रखें — मान कर चलें कि कुछ हिस्सा एडिट्स कुछ न कुछ तोड़ देंगे

मेरी ईमानदार राय: आज यह एक इंटरप्रेटेबिलिटी उपकरण और डीबगिंग का स्कैल्पल है, डिप्लॉयमेंट पाइपलाइन नहीं। जो टीमें पहले मूल्य निकालेंगी, वे वे नहीं होंगी जो प्रोडक्शन में वेट एडिट्स भेजेंगी। वे वे होंगी जो एक फ़्रंटियर मॉडल का इस्तेमाल अपने छोटे मॉडलों ने जो सीखा उसे समझाने के लिए करेंगी — चेकपॉइंट्स को उसी तरह पढ़ते हुए जैसे हम पहले से रीजनिंग ट्रेसेस पढ़ते हैं — और फिर उस ज्ञान पर साधारण, उबाऊ, भरोसेमंद उपकरणों से कार्रवाई करेंगी।

ग्रेडिएंट मरे नहीं हैं — उनका दर्जा घटा है

यहीं मेरा शुरुआती दावा टूटता है, और मैं इस पर ईमानदार रहना चाहता हूँ। ग्रेडिएंट डिसेंट वह कर सकता है जो वेट-स्पेस प्रोग्रामिंग नहीं कर सकती: बड़े पैमाने पर डेटा से सीखना। इन एडिट्स के लिए Astra ने जो भी क्षमता इस्तेमाल की, वह खुद एक विशाल ट्रेनिंग कॉर्पस पर ग्रेडिएंट्स द्वारा ही स्थापित की गई थी। रीजनिंग किसी नेटवर्क के ज्ञान पर सर्जरी कर सकती है; वह नेटवर्क को मानव-पाठ के पूरे योग को नहीं सिखा सकती। यथार्थवादी भविष्य ग्रेडिएंट्स का प्रतिस्थापन नहीं, बल्कि काम का बँटवारा है। ग्रेडिएंट्स नींव की कंक्रीट डालते हैं; वेट-स्पेस प्रोग्रामिंग फिनिश का काम करती है। चालीस साल तक हमने प्रशिक्षित वेट्स को एक अपारदर्शी कलाकृति माना, एक ब्लैक बॉक्स जिसे केवल बाहर से चलाया जा सकता था। यहाँ नया विचार यह है कि वह बॉक्स पढ़ने योग्य बन रहा है — और उसे पढ़ने वाला हम नहीं हैं। यह सुकून देने वाला है या चिंताजनक, यह शायद इस पर निर्भर करता है कि आपने ग्रेडिएंट्स पर कितना भरोसा किया था।