Mercury 2: Diffusion द्वारा संचालित सबसे तेज़ Reasoning LLM

#परिचय

पिछले एक दशक के अधिकांश समय से, artificial intelligence के परिदृश्य पर एक ही monolithic आर्किटेक्चर का दबदबा रहा है: autoregressive Transformer. GPT-2 से लेकर OpenAI के o3 जैसे reasoning models के नवीनतम वर्ज़न तक, जनरेशन का मूल तंत्र काफी हद तक एक जैसा ही रहा है - एक बार में एक discrete स्टेप के साथ, अगले token की भविष्यवाणी करना। हालांकि यह तरीका निर्विवाद रूप से शक्तिशाली है, लेकिन यह left-to-right sequential generation प्रोसेस एक अपरिहार्य latency bottleneck पैदा करता है, खासकर जब जटिल Chain-of-Thought (CoT) reasoning को एग्जीक्यूट किया जा रहा हो।

आज यह प्रतिमान (paradigm) बदल रहा है। Inception Labs ने Mercury 2 की घोषणा के साथ यथास्थिति को तोड़ दिया है, जिसे दुनिया के सबसे तेज़ reasoning LLM के रूप में पेश किया गया है, जो पूरी तरह से diffusion models द्वारा संचालित है। मॉडल कैसे "सोचते" हैं और टेक्स्ट जनरेट करते हैं, इस दिशा में यह एक बहुत बड़ी छलांग है।

#क्या हुआ

आज सुबह घोषित होने के बाद और तेज़ी से Hacker News के शीर्ष पर पहुँचने वाला, Mercury 2 मानक token generation से एकदम अलग तरीका पेश करता है। Inception Labs ने natural language reasoning के discrete डोमेन में continuous diffusion प्रोसेस—Midjourney और Stable Diffusion जैसे image generators के पीछे के गणितीय सिद्धांतों—को सफलतापूर्वक लागू किया है।

पिछले शब्दों के आधार पर अगले शब्द की भविष्यवाणी करने के बजाय, Mercury 2 tokens को एक continuous latent space में एम्बेड करता है। इसके बाद यह एक साथ पूरे sequence पर एक denoising प्रोसेस लागू करता है। इसका मतलब यह है कि यह केवल अपनी विचार प्रक्रिया को शब्द-दर-शब्द नहीं लिखता है; यह एक ही बार में पूरे लॉजिकल स्ट्रक्चर का मूल्यांकन करता है, और पारंपरिक मॉडलों द्वारा लिए जाने वाले समय के एक छोटे से हिस्से में noise के एक ब्लॉक को एक coherent, अत्यधिक सटीक reasoning path और अंतिम उत्तर में रिफाइन करता है।

#यह मायने क्यों रखता है

Latency, यूज़र एक्सपीरियंस और एप्लिकेशन डेवलपमेंट के लिए इसके परिणाम बहुत गहरे हैं।

एक पारंपरिक autoregressive मॉडल में, यदि किसी प्रॉम्प्ट को 50-token का उत्तर देने से पहले 2,000 tokens की internal reasoning की आवश्यकता होती है, तो यूज़र (या सिस्टम) को सभी 2,000 tokens के क्रमिक (sequentially) रूप से जनरेट होने का इंतज़ार करना पड़ता है। Sequence length के साथ Memory bandwidth और compute पर रेखीय (linearly) रूप से दबाव पड़ता है।

Mercury 2 मौलिक रूप से इस समीकरण को बदल देता है। Parallel iterative refinement का उपयोग करके, मॉडल आवश्यक लॉजिकल गहराई की परवाह किए बिना, लगभग स्थिर (near-constant) संख्या में diffusion steps में अंतिम reasoned आउटपुट पर पहुँच जाता है।

इसका अर्थ है Time-to-First-Token (TTFT) और समग्र (overall) generation latency में भारी कमी। Real-time एप्लिकेशन—जैसे voice agents, instant code review tools, या dynamic UI generators—बनाने वाले डेवलपर्स के लिए, यह उस भयानक "thinking..." स्पिनर को खत्म कर देता है। यह deep reasoning की शक्ति को उन latency-sensitive वातावरणों में लाता है जहाँ पहले व्यापक CoT मॉडलों को तैनात करना असंभव या आर्थिक रूप से अव्यवहार्य था।

#Technical Implications

Mercury 2 के पीछे की इंजीनियरिंग को सही मायनों में समझने के लिए, हमें यह देखना होगा कि diffusion टेक्स्ट को कैसे हैंडल करता है।

#1. Continuous Latent Projections

मानक language models discrete vocabularies पर काम करते हैं। आप किसी शब्द को दर्शाने वाले discrete integer को आसानी से "diffuse" नहीं कर सकते। Mercury 2 discrete tokens को एक high-dimensional continuous latent space में प्रोजेक्ट करके इस समस्या को हल करता है। Diffusion प्रोसेस—noise जोड़ना और उसे उलटने के लिए एक neural network को ट्रेन करना—अंतिम latent vectors को मानव-पठनीय (human-readable) टेक्स्ट में वापस प्रोजेक्ट करने से पहले पूरी तरह से इस continuous डोमेन के भीतर काम करता है।

#2. Parallel Denoising vs. Sequential Decoding

इस आर्किटेक्चरल बदलाव को कोर जनरेशन लूप्स को देखकर सबसे अच्छी तरह समझा जा सकता है:

# Pseudo-code comparison of generation logic

# Traditional Autoregressive (Slow, O(N))
def generate_autoregressive(prompt, max_tokens):
    context = prompt
    for _ in range(max_tokens):
        next_token = model.forward(context)
        context += next_token
    return context

# Mercury 2 Diffusion (Fast, O(Steps) where Steps << N)
def generate_diffusion(prompt, steps=20):
    latent_sequence = generate_pure_noise()
    for step in reversed(range(steps)):
        latent_sequence = model.denoise(latent_sequence, prompt, step)
    return project_to_text(latent_sequence)

जैसा कि ऊपर दर्शाया गया है, autoregressive जनरेशन लूप tokens ($N$) की संख्या से बंधा होता है। Mercury 2 का लूप denoising steps की संख्या से बंधा होता है, जो आउटपुट sequence length से पूरी तरह से अलग (decoupled) होता है।

#3. Latent Chain-of-Thought

शायद सबसे रोमांचक तकनीकी सफलता "Latent CoT" है। चूँकि Mercury 2 एक continuous space में काम करता है, इसलिए इसके intermediate reasoning steps को human-readable अंग्रेजी tokens में मैप करने की आवश्यकता नहीं होती है। यह abstract conceptual vectors में हेरफेर कर सकता है, अंतिम projection स्टेप तक व्याकरण (grammar), सिंटैक्स या फॉर्मेटिंग पर compute बर्बाद किए बिना इष्टतम (optimal) लॉजिकल पाथ खोज सकता है।

#आगे क्या?

Mercury 2 का रिलीज़ होना AI कम्युनिटी के लिए एक ऐतिहासिक पल (watershed moment) है। यह साबित करता है कि उन्नत (advanced) reasoning के लिए autoregressive Transformers ही आगे बढ़ने का एकमात्र व्यवहार्य (viable) रास्ता नहीं हैं, और यह निस्संदेह प्रमुख AI लैब्स के बीच प्रतिस्पर्धी (competing) diffusion-based टेक्स्ट मॉडल विकसित करने के लिए एक होड़ पैदा करेगा।

Ichiban Tools में, हम पहले से ही खोज कर रहे हैं कि हमारे डेवलपर यूटिलिटीज़ में Mercury-class मॉडल्स को कैसे इंटीग्रेट किया जाए। कल्पना करें कि आपको तुरंत, गहराई से सोचे गए (deeply-reasoned) आर्किटेक्चरल सुझाव और pull request रिव्यू प्राप्त हों, जो मिनटों के बजाय मिलीसेकंड में सामने आएं। हमें यह भी उम्मीद है कि open-source कम्युनिटी तेज़ी से इस आर्किटेक्चर को दोहराने (replicate) का प्रयास करेगी, जिससे संभावित रूप से छोटे, अति-तीव्र (hyper-fast) local reasoning models सामने आएंगे जो उपभोक्ता हार्डवेयर पर कुशलतापूर्वक चलेंगे।

#निष्कर्ष

Mercury 2 केवल एक और मॉडल रिलीज़ से कहीं अधिक है; यह एक बुनियादी आर्किटेक्चरल बदलाव (pivot) है। आधुनिक LLMs की deep reasoning क्षमताओं को diffusion models की parallel generation स्पीड के साथ जोड़कर, Inception Labs ने हमें artificial intelligence की अगली पीढ़ी की एक झलक दी है। मॉडलों द्वारा अपने विचारों को एक-एक token करके धीरे-धीरे टाइप करने का इंतज़ार करने का युग समाप्त हो रहा है। तात्कालिक (instantaneous), समग्र (holistic) reasoning का युग आखिरकार आ गया है।