Transformers के अंदर Programs Execute करना: Exponentially Faster Inference के साथ
#Introduction
Large Language Models (LLMs) ने इंसान जैसी टेक्स्ट समझने और जनरेट करने की अपनी क्षमता से दुनिया भर में धूम मचा दी है। लेकिन, इन मॉडल्स की शानदार probabilistic क्षमताओं के पीछे एक जानी-मानी रुकावट भी है: traditional transformer architectures लंबे, सटीक और deterministic computations को हैंडल करने में संघर्ष करते हैं। हालांकि theoretically ये Turing-complete हैं, लेकिन एक standard transformer के अंदर सीधे लाखों strict programmatic steps को execute करना ऐतिहासिक रूप से performance bottlenecks की वजह से लगभग नामुमकिन रहा है।
लेकिन क्या हो अगर हम इन limitations को पार करने के लिए attention mechanism को ही बदल दें? क्या हो अगर एक LLM सिर्फ एक टेक्स्ट जनरेटर न होकर, एक पूरी तरह से काम करने वाला, highly efficient कंप्यूटर बन जाए? Percepta की हालिया रिसर्च ने बिल्कुल यही कर दिखाया है—transformers के अंदर programs execute करने की एक नई अप्रोच, वो भी exponentially faster inference के साथ। यह सिर्फ एक छोटा सा optimization नहीं है; यह इस बात की पूरी तरह से नई कल्पना है कि एक neural network natively क्या प्रोसेस कर सकता है।
#What Happened
Percepta के researchers ने एक बहुत ही दिलचस्प सवाल पूछा: "क्या LLMs कंप्यूटर हो सकते हैं?" इसका जवाब देने के लिए, उन्होंने लंबे sequences में computational inefficiency की जड़ को टारगेट किया। एक standard transformer मॉडल में, attention mechanism को आमतौर पर हर नए जनरेट होने वाले token के लिए पूरे पिछले sequence को स्कैन करना पड़ता है। इससे हर step पर $O(n)$ time complexity होती है, जो लाखों steps वाले complex logic या math puzzles को execute करते समय बहुत जल्दी intractable हो जाती है।
इससे निपटने के लिए, टीम ने एक breakthrough architectural बदलाव पेश किया। Lookup heads को ठीक 2 dimension तक सीमित करके, उन्होंने standard attention mechanism को एक 2D convex-hull query में बदल दिया।
यह geometric बदलाव मॉडल के अपने state को retrieve और update करने की time complexity को sequence length के मुकाबले linear ($O(n)$) से logarithmic ($O(\log n)$) कर देता है। यह inference process को exponentially तेज़ कर देता है, जिससे modified transformer लाखों steps तक बिना किसी भारी performance गिरावट के एक "append-only trace" बनाए रख सकता है।
एक शानदार real-world demonstration में, टीम ने किसी external tool, code interpreter या API calls का सहारा नहीं लिया। इसके बजाय, उन्होंने दुनिया का सबसे कठिन Sudoku माने जाने वाले Arto Inkala Sudoku को सॉल्व करने के लिए transformer के अंदर ही एक compiled solver execute किया। मॉडल ने यह सिर्फ अपने internal "thought" process के दम पर हासिल किया, जिसे नए $O(\log n)$ attention mechanism से पावर मिली थी।
#Why It Matters
AI के साथ काम करने वाले developers और engineers के लिए, यह डेवलपमेंट एक बहुत बड़ी मुश्किल को हल करता है: probabilistic generation और strict, deterministic execution के बीच की दूरी।
फिलहाल, जब हम चाहते हैं कि कोई LLM सटीक गणित या complex logic execute करे, तो हम आमतौर पर उसके चारों ओर एक ढांचा (scaffolding) बनाते हैं। भारी और सटीक काम करवाने के लिए हम agents, function calling, या external code interpreters (जैसे Python sandboxes) का इस्तेमाल करते हैं। LLM एक orchestrator की तरह काम करता है, जबकि traditional compute environment असल execution को संभालता है।
Programs को सीधे transformer के weights के अंदर execute करने की क्षमता डालकर, हम external state management और complex orchestration layers की ज़रूरत को कम कर देते हैं। मॉडल खुद ही एक virtual machine (WebAssembly interpreter की तरह) चलाता है। जनरेट हुआ हर token इस virtual machine की किसी खास पल की state को दर्शाता है—instruction pointer को अपडेट करना, stack को मैनेज करना और memory को बदलना।
यह इसलिए मायने रखता है क्योंकि यह deterministic operations की latency को काफी कम कर देता है, जबकि उन natural language interfaces को बनाए रखता है जो LLMs को इतना पावरफुल बनाते हैं। यह साबित करता है कि neural networks अपने अंदर creative reasoning और rigorous computation के बीच के अंतर को पाट सकते हैं।
#Technical Implications
2D convex-hull queries के ज़रिए $O(n)$ से $O(\log n)$ attention की तरफ जाना, इस बात पर गहरा technical असर डालता है कि हम AI systems को कैसे डिज़ाइन और डिप्लॉय करते हैं। आइए अहम architectural बदलावों और उनके असर को समझते हैं:
#1. Geometric Attention Mechanisms
Standard dot-product attention high-dimensional spaces में compatibility scores कैलकुलेट करता है, जो computationally बहुत महंगा होता है। Key-value lookups को 2D space में प्रोजेक्ट करके और उन्हें convex-hull queries की तरह ट्रीट करके, मॉडल highly optimized geometric algorithms का फायदा उठा सकता है। इससे न सिर्फ retrieval तेज़ होता है, बल्कि memory access का एक ज़्यादा structured और deterministic pattern भी लागू होता है, जो program execution के लिए बहुत ज़रूरी है।
#2. State Management via Append-Only Traces
एक traditional computing environment में, memory mutable होती है। एक autoregressive transformer में, sequence append-only होता है। एक virtual machine चलाने के लिए, मॉडल को अपनी पूरी state (registers, stack, memory pointers) को output sequence में encode करना पड़ता है।
- Instruction Pointer: Compiled program की current line को ट्रैक करता है।
- Stack Representation: Push/pop operations को sequence additions के रूप में encode करता है।
- Memory Updates: Logarithmic attention head का इस्तेमाल करके हिस्ट्री को query करके किसी खास variable की सबसे ताज़ा value निकालता है।
#3. Compilation into Weights
शायद सबसे हैरान करने वाली बात यह है कि सॉफ्टवेयर को सीधे मॉडल के weights में compile किया जा सकता है। अगर एक transformer virtual machine चला सकता है, तो theoretically हम किसी भी deterministic program (जैसे sorting algorithm, physics engine, या cryptographic hashing function) को एक ऐसे फॉर्मेट में compile कर सकते हैं जिसे मॉडल natively execute कर सके। यह एक pre-trained neural network और compiled binary executable के बीच की लाइन को धुंधला कर देता है।
#What's Next
Arto Inkala Sudoku solver का सफलतापूर्वक execute होना सिर्फ एक शुरुआत है। जैसे-जैसे यह रिसर्च आगे बढ़ेगी, हम कई शानदार developments की उम्मीद कर सकते हैं:
- Hybrid Architectures: Future foundation models में semantic reasoning के लिए standard high-dimensional attention heads और खासतौर पर strict logic और state tracking के लिए 2D convex-hull heads का मिक्स हो सकता है।
- Native Code Execution: हम कुछ खास तरह की समस्याओं के लिए external code interpreters से पूरी तरह दूर हो सकते हैं, और inference pass के दौरान sandboxed bytecode को natively execute करने के लिए मॉडल पर ही निर्भर हो सकते हैं।
- Enhanced Reasoning Capabilities: Deterministic execution को core architecture में शामिल करके, strict mathematical proofs या complex data transformations की ज़रूरत वाले कामों में मॉडल्स बहुत कम hallucinate करेंगे।
Ichiban Tools कम्युनिटी के लिए, इसका मतलब है कि हम LLMs के ऊपर जो utilities और developer tools बनाते हैं, वे काफी तेज़ और ज़्यादा reliable होने वाले हैं। एक LLM के forward pass में सीधे complex parsing या static analysis को integrate करने की संभावना, developer productivity के लिए बिल्कुल नए रास्ते खोलती है।
#Conclusion
यह समझना कि LLMs highly efficient computers के रूप में काम कर सकते हैं, artificial intelligence में एक बहुत बड़ा मील का पत्थर है। Attention mechanism को पूरी तरह से नए नज़रिए से देखकर और logarithmic inference times हासिल करने के लिए 2D convex-hull queries का इस्तेमाल करके, researchers ने transformers के लिए लंबे, deterministic programs को natively execute करने की क्षमता को अनलॉक कर दिया है।
जैसे-जैसे हम यह खोजते रहेंगे कि neural networks क्या-क्या कर सकते हैं, probabilistic reasoning और exact computation का मिलन यकीनन ज़्यादा मज़बूत, काबिल और versatile AI systems को जन्म देगा। अब हम सिर्फ मॉडल्स को अगला शब्द predict करना नहीं सिखा रहे हैं; हम उन्हें अगला instruction execute करना सिखा रहे हैं।