- LLM गणित ओलंपियाड स्तर की समस्याएँ हल कर लेते हैं, लेकिन साधारण जोड़/सुडोकू तक बाहरी टूल्स के बिना सटीक रूप से नहीं कर पाते। इस सीमा को पार करने के लिए Transformer के भीतर एक वास्तविक कंप्यूटर बनाने का दृष्टिकोण प्रस्तुत किया गया है
- मनमाने C code को tokens में बदलकर, मॉडल स्वयं लाखों steps की execution trace सीधे उत्पन्न करता है, और CPU पर प्रति सेकंड 30 हज़ार से अधिक tokens की गति से streaming संभव है
- मुख्य तकनीक attention head dimension को 2D तक सीमित कर उसे convex hull आधारित geometric search में बदलना है, जिससे linear-time scan को log-time से बदला जा सके
- WebAssembly interpreter को Transformer weights में लागू करके, बाहरी tool call के बिना मॉडल के decoding loop के भीतर ही program execution पारदर्शी रूप से होता है
- आगे चलकर programs को सीधे weights में compile करने और learned representations तथा compiled algorithms को एकीकृत computational substrate में जोड़ने वाले AI systems तक विस्तार की संभावना दिखाई गई है
LLM की computational सीमाएँ
- अत्याधुनिक LLM अंतरराष्ट्रीय गणित ओलंपियाड के gold medal स्तर की समस्याएँ हल कर सकते हैं या अनसुलझी गणित/विज्ञान समस्याओं पर काम कर सकते हैं, लेकिन शुद्ध computation वाले कामों में अब भी विफल रहते हैं
- बुनियादी जोड़ में भी त्रुटियाँ होती हैं, और Sudoku-Bench जैसे benchmarks में बाहरी मदद के बिना समाधान की सफलता दर बहुत कम रहती है
- अभी इस अंतर को भरने के दो workaround मौजूद हैं
- Tool use: मॉडल code लिखता है, बाहरी interpreter उसे चलाता है और परिणाम लौटाता है
- Agent orchestration: बाहरी loop मध्यवर्ती state सहेजता है, काम को छोटे हिस्सों में बाँटता है और मॉडल को बार-बार कॉल करता है
- ये तरीके उपयोगी हैं, लेकिन यह भी उजागर करते हैं कि वास्तविक computational क्षमता अब भी मॉडल के बाहर मौजूद है
- उपमा के तौर पर, इंसानों ने हवाई जहाज़ बना लिया, इसका अर्थ यह नहीं कि इंसान स्वयं उड़ सकते हैं
- मॉडल computation के बारे में reason कर सकता है या tools को coordinate कर सकता है, लेकिन यदि वह स्वयं execute नहीं कर सकता, तो वह वास्तव में कंप्यूटर नहीं है
Transformer को कंप्यूटर कैसे बनाया गया
- कई शोध यह दिखा चुके हैं कि Transformer architecture सैद्धांतिक रूप से Turing machine का simulation कर सकती है, लेकिन सैद्धांतिक expressivity व्यावहारिक execution efficiency की गारंटी नहीं देती
- शुद्ध सैद्धांतिक computation model की जगह, आधुनिक RAM कंप्यूटर को Transformer के भीतर लागू किया गया, जहाँ हर instruction अधिकतम 5 tokens से मैप होती है
- लेकिन गहरी समस्या decoding प्रक्रिया में ही मौजूद है
- मानक autoregressive decoding हर step पर लगातार बढ़ती पूरी history के साथ interact करती है
- KV caching अतीत के key/value की पुनर्गणना से बचाती है, लेकिन cache के आकार के अनुपात में attention cost फिर भी बनी रहती है
- इस सीमा को हल करने के लिए attention head dimension को 2D तक सीमित किया गया, और execution-style trace के लिए efficient decoding path पेश किया गया
- प्रमुख lookup/update operations sequence length के सापेक्ष log-time में की जा सकती हैं
- इससे Transformer के भीतर लाखों steps वाले programs चलाना संभव हो जाता है
computation का अर्थ — Tool use बनाम model के भीतर execution
- पारंपरिक tool use में मॉडल
python -c "print(3+5)" जैसे code को आउटपुट करता है → बाहरी interpreter उसे चलाता है → परिणाम token stream में inject किया जाता है
- इस system में WebAssembly interpreter को Transformer weights में लागू किया गया है
- WebAssembly तेज़ और deterministic execution के लिए low-level instruction set है और C/C++ के लिए एक general-purpose compile target भी
- 3 + 5 की गणना के समय मॉडल wasm instructions (
i32.const, i32.add) आउटपुट करता है और फिर fast decoding mode में जाकर step-by-step execution trace स्वयं उत्पन्न करता है
- मुख्य अंतर
- Tool use opaque है: मॉडल control छोड़ देता है और black-box उत्तर प्राप्त करता है
- model के भीतर execution transparent है: सभी मध्यवर्ती steps trace में दिखते हैं, और मॉडल अपने decoding loop से बाहर नहीं जाता
Sudoku demo — सटीक दीर्घकालिक computation का stress test
- सीखे हुए neural network आधारित तरीके आसान Sudoku पर अच्छा प्रदर्शन दिखाते हैं, लेकिन कठिन समस्याओं पर पूरी तरह विफल हो जाते हैं
- आम व्याख्या यह रही है कि autoregressive models constraint satisfaction problems के लिए मूलतः अनुपयुक्त हैं, लेकिन यह system पूरी तरह autoregressive होते हुए भी 100% accuracy हासिल करता है
- वास्तविक bottleneck autoregressive paradigm नहीं, बल्कि यह है कि कठिन Sudoku बहुत लंबी execution trace मांगता है और मानक attention लंबे context generation को अव्यावहारिक बना देती है
- पूर्ण Sudoku solver को compile करके Transformer के भीतर चलाया गया, जहाँ learned heuristics के बजाय वास्तविक algorithm step-by-step चलाया जाता है
- Arto Inkala के "दुनिया के सबसे कठिन Sudoku" को 3 मिनट से कम समय में सही हल किया गया
- यदि compiled solver सही है, तो Transformer का execution भी सही होगा — ऐसी सार्वभौमिक गारंटी दी जाती है
computation को encode करने का तरीका — append-only trace
- autoregressive Transformer को ऐसी मशीन की तरह समझा जा सकता है जो अपनी ही history के भीतर रहती है
- पारंपरिक कंप्यूटर editable memory को update करते हैं, लेकिन Transformer में ऐसी अवधारणा नहीं होती
- इसमें एक fixed prompt (input/program) और लगातार बढ़ती trace (generated tokens) होती है
- append-only notebook की उपमा
- शुरुआती पंक्तियाँ input (prompt) हैं, और उसके बाद हर पंक्ति computation का अगला step रिकॉर्ड करती है
- पुरानी पंक्तियों को बदला नहीं जा सकता, और हर step पर केवल कुछ ही पिछली positions को refer किया जा सकता है
- कई algorithms को ऐसे व्यक्त किया जा सकता है: "ऐसी append-only trace जिसमें हर step पर केवल स्थिर संख्या की कुछ पिछली positions ही refer की जाती हैं"
- इस system में मॉडल द्वारा उत्पन्न tokens virtual machine की बदलती हुई state को व्यक्त करते हैं, जैसे instruction pointer, memory/stack operations, arithmetic, control flow, output
- attention heads एक shared 1D array की तरह काम करते हैं, जहाँ हर token किसी index पर value लिखता है और दूसरे index से value पढ़ता है — यानी write-then-read primitive
- attention cumulative sums भी compute कर सकती है, जिससे instruction pointer, stack depth आदि को delta increments के cumulative sum के रूप में track किया जा सकता है
मुख्य unlock: घातांकीय रूप से तेज़ attention
- वास्तविक कंप्यूटर हर instruction पर लगभग स्थिर मात्रा का काम करके छोटा state update करते हैं, लेकिन मानक Transformer tवें decoding step पर लंबाई t के prefix के साथ interact करता है, जिससे कुल लागत quadratic बढ़ती है
- HullKVCache के परिचय से इस quadratic विस्फोट को हल किया गया
- वास्तविक benchmarks में HullKVCache की गति 31,037 tokens/second (6,747 lines/second) रही, जबकि मानक KVCache 272 tokens/second (59 lines/second) पर रहा — यानी लगभग 114x का अंतर
- प्रति step Θ(t) समय के बजाय attention lookup O(log t) समय में किया जाता है
-
2D attention का fast path
- लक्ष्य सामान्य रूप से Transformer को accelerate करना या कोई नई architecture लाना नहीं, बल्कि vanilla Transformer में head dimension को 2D तक सीमित करने जैसी संभालने योग्य parameterization पर ध्यान देना है
d_model = 36, n_heads = 18 के साथ हर head ठीक 2 dimensions का है; 7 layers, मानक nn.MultiheadAttention, और gated feedforward network का उपयोग किया गया
- कोई custom attention kernel या sparse mask नहीं, बल्कि शुद्ध vanilla PyTorch का उपयोग
- layers की संख्या, heads की संख्या, और embedding size को मनचाहा बड़ा रखा जा सकता है, इसलिए पूरे model का छोटा होना आवश्यक नहीं
n_heads = d_model / 2 रखकर अधिक heads इस्तेमाल किए जा सकते हैं
-
2D attention का geometric दृष्टिकोण
- attention mechanism में, पुराना token 2D key vector kⱼ और value vⱼ देता है, वर्तमान step query q बनाता है और जिस key का inner product अधिकतम हो, उसकी value लौटती है (hardmax attention)
- यह computational geometry की क्लासिक "supporting point query" समस्या के बिल्कुल समान है: दिशा q दिए जाने पर convex hull पर उस दिशा में सबसे दूर बिंदु खोजना
- token generation के साथ-साथ convex hull data structure बनाए रखकर पूरे अतीत के points पर log-time lookup संभव हो जाता है
- memory/stack operations के लिए "index i पर सबसे हाल में store की गई value" को lookup करना पड़ता है, और यही 2D key की आवश्यकता का कारण है
- index j को 2D key
kⱼ = (2j, -j²) के रूप में store करके और दिशा q = (i, 1) से query करने पर quadratic पद -j² ऐसा penalty देता है कि सिर्फ सटीक match ही जीतता है
- Turing completeness के लिए 2D attention पर्याप्त है, और जैसा इस ब्लॉग में दिखाया गया है, इससे पूरा RAM कंप्यूटर व्यक्त किया जा सकता है
आगे की योजना
-
अधिक समृद्ध attention mechanisms
- वर्तमान implementation hardmax attention का उपयोग करती है, लेकिन यह कोई मूलभूत सीमा नहीं है
- इसे k-sparse softmax attention से approximate किया जा सकता है: nested convex hulls से top-k keys निकालकर केवल उन पर softmax चलाना, जिसकी लागत
O(k + log n) होती है
- यह geometric fast path केवल executor structure तक सीमित नहीं है; सिद्धांततः 2D heads वाले किसी भी Transformer के decoding time को accelerate कर सकता है
- 3D heads तक इसका स्वाभाविक विस्तार 3D convex hull के माध्यम से संभव है, हालांकि अधिक dimensions पर efficiency तेज़ी से घटती है
-
2D heads के साथ large-scale models का training
- 2D head parameterization स्वभावतः छोटी नहीं है — अधिक heads और layers के साथ मानक Transformer जैसी कुल parameter count बनाए रखी जा सकती है
- इसके कई उपयोग मोड हो सकते हैं
- धीमे और अधिक general models के साथ जुड़ने वाला dedicated fast path
- एक ही system के भीतर fast/slow hybrid architecture
- speculative decoding, जहाँ 2D model जल्दी tokens प्रस्तावित करे और सामान्य attention model उन्हें verify करे
- execution trace forward pass का हिस्सा होने के कारण पूरी प्रक्रिया differentiable है — यह बाहरी tools से मूलभूत रूप से अलग है, और बड़े models में सीधे जोड़े जा सकने वाले learnable compute substrate का आधार बनती है
-
programs को weights में compile करना
- अभी मॉडल weights में encoded interpreter को सीखता है, लेकिन यदि weight-generating compile machine का विस्तार किया जाए, तो बिना token sequence के मनचाहे program को सीधे weights में compile करना संभव हो सकता है
- तब weights स्वयं software का deployment target बन जाएँगे; मॉडल software-जैसा व्यवहार सीखने के बजाय compiled program logic को अपने internal circuit के हिस्से के रूप में समाहित करेगा
- यदि logic को weights में compile किया जा सकता है, तो gradient descent ही मॉडल बदलने का एकमात्र तरीका नहीं रहेगा — structure, algorithms, और guarantees को network में सीधे डाला जा सकेगा
- अंततः यह ऐसे systems की ओर बढ़ सकता है जो केवल अनुभव से सीखते ही नहीं, बल्कि अपने weights को बदलकर या विस्तार देकर अपनी internal machine को स्वयं rewrite भी कर सकें
-
AI systems को software की तरह बढ़ाना
- जैसे आधुनिक software ecosystem modules, abstractions, और reusable components जमा करते हुए विकसित हुआ है, वैसे ही AI systems के भीतर भी नई computational क्षमताएँ धीरे-धीरे जोड़ी जा सकती हैं
- नई functionality को पूरे system को फिर से train किए बिना मौजूदा circuits से जोड़ा जा सकता है
- भविष्य के AI systems केवल software का उपयोग नहीं करेंगे, बल्कि software को अपने भीतर समाहित करेंगे, और learned representations तथा compiled algorithms को एक ही computational substrate में एकीकृत करेंगे
अभी कोई टिप्पणी नहीं है.