Qwen3-Next: डेमो प्रोजेक्ट के साथ एक गाइड

Qwen टीम ने हाल ही में Qwen3-Next-80B-A3B मॉडल लॉन्च किया है, जो उन्नत रीजनिंग, अल्ट्रा-लॉन्ग कॉन्टेक्स्ट हैंडलिंग और असाधारण इंफेरेंस स्पीड को हाइब्रिड Mixture-of-Experts (MoE) आर्किटेक्चर के जरिए एक साथ लाता है।

इस गाइड में, मैं बताऊँगा कि Qwen3-Next-80B-A3B व्यावहारिक, वास्तविक-जीवन के कार्यों पर, पिछले Qwen मॉडलों जैसे Qwen3-30B-A3B की तुलना में कैसा प्रदर्शन करता है। अमूर्त बेंचमार्क की बजाय, हम हैंड्स-ऑन, साइड-बाय-साइड टेस्ट चलाएँगे—जिनमें रीजनिंग, कोड, और अल्ट्रा-लॉन्ग डॉक्युमेंट प्रॉम्प्ट शामिल होंगे—ताकि आप स्पीड, आउटपुट गुणवत्ता, और GPU मेमोरी उपयोग में ट्रेड-ऑफ देख सकें।

कदम-दर-कदम, मैं आपको दिखाऊँगा कि कैसे:

• OpenRouter API के जरिए बिना किसी सेटअप के Qwen3-Next-80B-A3B और Qwen3-30B-A3B दोनों तक पहुँचें और उनसे इंटरैक्ट करें
• Streamlit ऐप बनाएँ ताकि मॉडल रिस्पॉन्स, लेटेंसी और रिसोर्स उपयोग की त्वरित, साइड-बाय-साइड तुलना हो सके
• मॉडलों की वास्तविक सीमा परखने के लिए अल्ट्रा-लॉन्ग कॉन्टेक्स्ट रिट्रीवल प्रयोग (100K+ टोकन) चलाएँ
• लेटेंसी, tokens/sec, और VRAM उपयोग जैसे वास्तविक-परिस्थिति प्रदर्शन मेट्रिक्स का विश्लेषण करें।

अंत में, आपका ऐप कुछ इस तरह दिखेगा:

Qwen3-Next क्या है?

Qwen3-Next एक 80B पैरामीटर वाला Mixture-of-Experts (MoE) मॉडल है। व्यवहार में, यह प्रति टोकन केवल 3B पैरामीटर एक्टिवेट करता है, जिससे यह पुराने डेंस मॉडलों (जैसे Qwen3-32B) की तुलना में ट्रेनिंग में दस गुना सस्ता और रन में दस गुना तेज हो सकता है, जबकि गुणवत्ता में उनकी बराबरी करता है या उन्हें पीछे छोड़ देता है।

इस मॉडल में कुछ प्रमुख प्रगति शामिल हैं:

• हाइब्रिड आर्किटेक्चर: Qwen3-Next 75:25 के अनुपात में Gated DeltaNet (तेज़ लीनियर अटेंशन के लिए) और Gated Attention (डीप रिकॉल के लिए) का मिश्रण उपयोग करता है, जिससे दोनों तरीकों की खूबियाँ मिलती हैं।
• अल्ट्रा-स्पार्स MoE: यह 512 एक्सपर्ट्स का उपयोग करता है लेकिन प्रति इंफेरेंस केवल 10+1 एक्टिवेट करता है, जिससे डेंस LLMs की तुलना में 90% से अधिक कंप्यूटेशन घटता है
• मल्टी-टोकन प्रेडिक्शन: यह मॉडल speculative decoding का समर्थन करता है, जिससे विशेषकर स्ट्रीमिंग या चैट में बड़ी स्पीड बढ़त मिलती है।
• अत्यधिक लंबा कॉन्टेक्स्ट: यह 256K टोकन तक नैटिव रूप से प्रोसेस करता है (YaRN स्केलिंग के साथ 1M+), वह भी न्यूनतम प्रदर्शन गिरावट के साथ, और लंबे किताबों, कोडबेस आदि के लिए आदर्श है।

स्रोत: Qwen

Qwen 3 Next मॉडल दो वेरिएंट में उपलब्ध है:

• Qwen3-Next-80B-A3B-Instruct: यह मॉडल जनरल-पर्पस चैट, कोडिंग, और ओपन QA के लिए बनाया गया है।
• Qwen3-Next-80B-A3B-Thinking: यह मॉडल उन्नत रीजनिंग, चेन-ऑफ-थॉट, और रिसर्च वर्कफ़्लोज़ के लिए उपयोग किया जा सकता है।

डेमो: OpenRouter API के साथ Qwen3-Next पर Q&A और रीजनिंग

इस खंड में, मैं दिखाऊँगा कि OpenRouter API के जरिए Qwen3-Next मॉडल का उपयोग करके एक इंटरैक्टिव QA और रीजनिंग असिस्टेंट कैसे बनाते हैं।

यह ऐसे काम करता है:

• टेक्स्टबॉक्स में कोई प्रश्न दर्ज करें, या कोई लंबा PDF डॉक्युमेंट ड्रैग-एंड-ड्रॉप करें।
• Max token आकार और model name ड्रॉपडाउन से चुनें
• दो मॉडलों को तुरंत साइड-बाय-साइड क्वेरी करें और आउटपुट की सीधी तुलना करें।
• हर रन के लिए विस्तृत मेट्रिक्स देखें—जैसे रिस्पॉन्स समय (लेटेंसी), प्रति सेकंड टोकन, और आउटपुट लंबाई—ताकि आप व्यावहारिक परिदृश्यों में प्रदर्शन और दक्षता दोनों समझ सकें।

स्टेप 1: पूर्व आवश्यकताएँ

यह डेमो चलाने से पहले, सुनिश्चित कर लें कि सभी पूर्व आवश्यकताएँ पूरी हैं।

स्टेप 1.1: इम्पोर्ट्स 

सबसे पहले, यह सुनिश्चित करें कि आपके पास निम्न इम्पोर्ट्स इंस्टॉल हों:

pip install streamlit requests pypdfसंचालित द्वारा

यह कमांड ऐप बनाने के लिए आवश्यक सभी कोर डिपेंडेंसीज़ इंस्टॉल करता है—यानी UI के लिए Streamlit, API कॉल के लिए requests, और PDF डॉक्युमेंट एक्सट्रैक्शन के लिए pypdf।

स्टेप 1.2: OpenRouter API कुंजी सेट करना 

Qwen3-Next मॉडल आधिकारिक Qwen API (AlibabaCloud), HuggingFace, और क्वांटाइज़्ड वर्ज़न के रूप में Ollama के माध्यम से भी उपलब्ध है। इस ट्यूटोरियल के लिए, मैंने OpenRouter का उपयोग किया, जो एक ही API कुंजी से कई मॉडलों तक पहुँच देता है। यहाँ बताया गया है कि Qwen3-next-80b-a3b-instruct मॉडल के लिए अपनी API कुंजी कैसे सेट करें:

• यहाँ खाता बनाएँ: https://openrouter.ai/
• Models टैब पर जाएँ और “Qwen3-next-80b-a3b-instruct” और “Qwen3-30B-A3B” मॉडलों को खोजें। आप अपनी एप्लिकेशन के अनुसार Thinking और Instruct वेरिएंट में से चुन सकते हैं। इस ट्यूटोरियल में, मैं दोनों Instruct मॉडल वेरिएंट की तुलना करता हूँ।

• नीचे स्क्रॉल करें और Create API Key पर क्लिक करें। कुंजी का नाम और क्रेडिट लिमिट (वैकल्पिक) भरें, और Create पर क्लिक करें। इस API कुंजी को आगे के उपयोग के लिए सुरक्षित रखें. 

• इसके बाद, Credits टैब पर जाएँ और अपना कार्ड या बैंक जानकारी जोड़ें। आप Amazon Pay या क्रिप्टो के जरिए भी भुगतान कर सकते हैं। इस डेमो के लिए, मैंने लगभग $8 जोड़े, जो पर्याप्त था।

अब, ऐप चलाने से पहले अपनी API कुंजी को एक एनवायरनमेंट वेरिएबल के रूप में सेट करें:

export OPENROUTER_API_KEY=your_api_keyसंचालित द्वारा

स्टेप 2: मॉडल कॉन्फ़िगरेशन सेट करना

हम उन मॉडलों को कॉन्फ़िगर करके शुरू करते हैं जिन्हें हम तुलना करना चाहते हैं। हर मॉडल को एक आइडेंटिफ़ायर (API कॉल्स के लिए), कुल पैरामीटर काउंट, और एक्टिव पैरामीटर काउंट के साथ परिभाषित किया गया है।

import streamlit as st
import requests
import time
import PyPDF2
MODEL_CONFIG = {
    "Qwen3-Next-80B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-instruct",
        "params_billion": 80,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-30b-a3b-instruct-2507",
        "params_billion": 30,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-thinking",
        "params_billion": 30,
        "active_params_billion": 3
    },
}संचालित द्वारा

हम Streamlit वेब ऐप बनाने के लिए आवश्यक लाइब्रेरीज़ इम्पोर्ट करते हैं—जैसे UI के लिए streamlit, API कॉल्स के लिए requests, टाइमिंग के लिए time, और PDF टेक्स्ट एक्सट्रैक्शन के लिए PyPDF2।

इसके बाद, हम MODEL_CONFIG डिक्शनरी परिभाषित करते हैं, जो तुलना के लिए उपलब्ध मॉडलों को कवर करती है—उनके यूनिक आईडी (API कॉल्स के लिए) और पैरामीटर काउंट सहित—ताकि पूरे ऐप में विभिन्न Qwen3 मॉडलों को बढ़ाना आसान हो।

स्टेप 3: हेल्पर फ़ंक्शंस

इसके बाद, हम बैकएंड के लिए कई हेल्पर फ़ंक्शंस परिभाषित करते हैं। इनमें मेमोरी आवश्यकताओं का आकलन करना, OpenRouter को रियल-टाइम API कॉल्स करना, और अपलोड किए गए PDFs से टेक्स्ट निकालना शामिल है।

def estimate_vram(params_billion, fp16=True, active_params_billion=None):
    if active_params_billion and active_params_billion != params_billion:
        total_params = params_billion * 1e9
        active_params = active_params_billion * 1e9
        size_bytes = 2 if fp16 else 4
        storage_vram = total_params * size_bytes / 1e9
        moe_overhead = active_params * 0.5 / 1e9  
        system_overhead = storage_vram * 0.2  
        total_vram = storage_vram + moe_overhead + system_overhead
    else:
        size_bytes = 2 if fp16 else 4
        num_params = params_billion * 1e9
        base_vram = num_params * size_bytes / 1e9
        total_vram = base_vram * 1.3 
    return round(total_vram, 1)
def query_openrouter(model_id, prompt, max_tokens=2048):
    api_key = "sk-or-v1-xxxxxxxxxxxxxxxxxxxxx" # Add your API Key here
    url = "https://openrouter.ai/api/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "model": model_id,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens
    }
    try:
        start = time.time()
        response = requests.post(url, headers=headers, json=data, timeout=180)
        elapsed = time.time() - start
        response.raise_for_status()
        j = response.json()
        output = j["choices"][0]["message"]["content"].strip()
        usage = j.get("usage", {})
        prompt_tokens = usage.get("prompt_tokens", 0)
        completion_tokens = usage.get("completion_tokens", 0)
        tokens_per_sec = (completion_tokens or 0) / elapsed if elapsed > 0 else 0
        return {
            "output": output,
            "latency": elapsed,
            "output_tokens": completion_tokens,
            "tokens_per_sec": tokens_per_sec,
            "prompt_tokens": prompt_tokens
        }
    except Exception as e:
        return {"error": str(e)}
def extract_pdf_text(uploaded_pdf):
    text = ""
    try:
        reader = PyPDF2.PdfReader(uploaded_pdf)
        for page in reader.pages:
            text += page.extract_text() or ""
        return text[:120000]  
    except Exception as e:
        return f"[PDF extract error: {str(e)}]"संचालित द्वारा

आइए समझते हैं कि हर फ़ंक्शन पाइपलाइन में कैसे फिट होता है:

• estimate_vram() फ़ंक्शन: यह फ़ंक्शन किसी मॉडल को चलाने के लिए आवश्यक GPU VRAM का अनुमान लगाता है, और देखता है कि मॉडल डेंस है या MoE (Mixture-of-Experts)। MoE मॉडलों के लिए यह कुल और एक्टिव पैरामीटर दोनों को ध्यान में रखता है और रूटिंग व सिस्टम उपयोग का ओवरहेड जोड़ता है।
• query_openrouter() फ़ंक्शन: यह फ़ंक्शन OpenRouter पर होस्टेड चुने हुए LLM मॉडल को प्रॉम्प्ट भेजने और रिस्पॉन्स प्राप्त करने के लिए ज़िम्मेदार है। यह कुल लेटेंसी (एंड-टू-एंड API कॉल समय) मापता है, प्रोसेस हुए टोकन जैसी उपयोगी मेट्रिक्स निकालता है, और टोकन-पर-सेकंड जेनरेशन रेट की गणना करता है. 

ध्यान दें कि यहाँ रिपोर्ट की गई लेटेंसी में नेटवर्क, क्यूइंग, और सर्वर-साइड देरी शामिल हैं—सिर्फ शुद्ध मॉडल इंफेरेंस स्पीड नहीं। इस प्रकार, यह वास्तविक-जीवन की एंड-टू-एंड प्रतिक्रियात्मकता को दर्शाता है, जो API लोड और इंटरनेट स्थिति के अनुसार बदल सकती है।

• extract_pdf_text() फ़ंक्शन: यह फ़ंक्शन उपयोगकर्ताओं को PDFs अपलोड करने और उन्हें मॉडलों के लिए इनपुट कॉन्टेक्स्ट के रूप में विश्लेषित करने में सक्षम बनाता है। यह PyPDF2 का उपयोग करके PDF डॉक्युमेंट को पार्स करता है और कच्चा टेक्स्ट निकालता है, बहुत लंबी फाइलों के लिए टोकन-सुरक्षित सीमा तक। यदि पार्सिंग विफल होती है, तो फ़ंक्शन एक त्रुटि संदेश लौटाता है।

ये हेल्पर फ़ंक्शंस कुशल मेमोरी उपयोग, विश्वसनीय API-आधारित इंफेरेंस, और स्मूथ कॉन्टेक्स्ट एक्सट्रैक्शन सुनिश्चित करते हैं, जिससे उपयोगकर्ता अनुभव निर्बाध रहता है।

स्टेप 4: Streamlit एप्लिकेशन

सभी कोर कंपोनेंट तैयार होने के साथ, अब हम अपना Streamlit एप्लिकेशन बना सकते हैं।

स्टेप 4.1: कस्टम CSS

यूज़र-फेसिंग वर्कफ़्लो बनाने का पहला कदम विज़ुअल डिज़ाइन और लेआउट है। यहाँ, हम Streamlit पेज कॉन्फ़िगर करते हैं और एक स्ट्रक्चर्ड लुक के लिए कस्टम CSS इंजेक्ट करते हैं।

st.set_page_config(page_title="Qwen3-Next QA & Reasoning", layout="wide", page_icon=" ")
st.markdown("""
<style>
    .main-header {
        text-align: center;
        
        
    }
    .metric-card {
        background-
        
        border-radius: 0.5rem;
        border-left: 4px solid #1f77b4;
        
    }
    .output-box {
        background-
        border: 2px solid #e1e5e9;
        border-radius: 0.5rem;
        
        
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    .model-header {
        background: linear-gradient(90deg, #1f77b4, #ff7f0e);
        color: white;
        
        border-radius: 0.5rem;
        
        text-align: center;
        font-weight: bold;
    }
</style>
""", unsafe_allow_html=True)
st.markdown('<h1 class="main-header"> QA and Reasoning With Qwen3-Next</h1>', unsafe_allow_html=True)
st.markdown("""
<div style="text-align: center; ">
    <p style="">
        Compare two Qwen3 models side-by-side with real-time performance metrics
    </p>
</div>
""", unsafe_allow_html=True)संचालित द्वारा

हम Streamlit की कॉन्फ़िगरेशन विकल्पों और कस्टम CSS स्टाइलिंग पैरामीटर्स दोनों का उपयोग करते हैं। st.set_page_config कॉल पेज टाइटल और साइड-बाय-साइड आउटपुट के लिए वाइड लेआउट सेट करता है। प्रमुख UI एलिमेंट्स को स्टाइल करने के लिए कस्टम CSS st.markdown के जरिए इंजेक्ट किया गया है।

.main-header टाइटल को सेंटर और कलर करता है, .metric-card और .output-box मेट्रिक्स और आउटपुट के डिस्प्ले को बेहतर बनाते हैं, और .model-header ग्रेडिएंट के साथ मॉडल रिस्पॉन्स को विज़ुअली अलग करता है। अंतिम st.markdown ब्लॉक एक हेडिंग और ऐप का संक्षिप्त विवरण रेंडर करता है।

स्टेप 4.2: इनपुट सेक्शन

हमने इनपुट सेक्शन को इस तरह डिज़ाइन किया है कि उपयोगकर्ताओं के पास दो सहज विकल्प हों: या तो संदर्भ के रूप में कोई लंबा PDF अपलोड करें या सीधे कोई कस्टम प्रश्न टाइप करें।

st.markdown("### Input")
with st.container():
    col_upload, col_text = st.columns([2, 3])
    with col_upload:
        uploaded_pdf = st.file_uploader(
            "Upload PDF for context", 
            type=["pdf"],
            help="Upload a PDF document to provide context for your question"
        )
    with col_text:
        user_question = st.text_area(
            "Ask a question:", 
            height=100, 
            max_chars=12000,
            placeholder="Enter your question here...",
            help="Ask any question or provide a topic to analyze"
        )संचालित द्वारा

यह इनपुट सेक्शन दो साइड-बाय-साइड कॉलम दिखाता है: पहला कॉलम उपयोगकर्ताओं को संदर्भ दस्तावेज़ जोड़ने के लिए PDF फाइल अपलोडर देता है, जबकि दूसरा कॉलम प्रश्न या विषय दर्ज करने के लिए टेक्स्ट एरिया प्रदान करता है। यह इंटरफ़ेस उपयोगकर्ताओं को PDF अपलोड करने, प्रश्न टाइप करने, या दोनों का एक साथ इनपुट के रूप में उपयोग करने की सुविधा देता है।

स्टेप 4.3: मॉडल चयन

मॉडल चयन खंड उपयोगकर्ताओं को यह नियंत्रित करने की पूरी क्षमता देता है कि किन Qwen मॉडलों की तुलना करनी है, और मॉडल रिस्पॉन्स कितने लंबे हो सकते हैं। दस्तावेज़ संदर्भ सेट होने के बाद, उपयोगकर्ता ड्रॉपडाउन से आसानी से कोई भी दो मॉडल चुन सकते हैं, साथ ही वांछित अधिकतम रिस्पॉन्स लंबाई (टोकन में), जिससे छोटे और लंबे—दोनों प्रकार के आउटपुट के साथ प्रयोग करना आसान हो जाता है।

context = ""
if uploaded_pdf:
    with st.spinner(" Extracting PDF text..."):
        context = extract_pdf_text(uploaded_pdf)
    st.success(f" PDF loaded: {len(context)//1000}K characters extracted.")
st.markdown("### Model Selection")
model_names = list(MODEL_CONFIG.keys())
col1, col2, col3 = st.columns([2, 2, 1])
with col1:
    model1 = st.selectbox(
        "Model A", 
        model_names, 
        index=0,
        help="Select the first model to compare"
    )
with col2:
    model2 = st.selectbox(
        "Model B", 
        model_names, 
        index=1 if len(model_names) > 1 else 0,
        help="Select the second model to compare"
    )
with col3:
    max_tokens = st.selectbox(
        "Max Tokens",
        [512, 1024, 2048, 4096],
        index=2,  
        help="Maximum length of response (higher = longer responses). Use 2048+ for reasoning questions."
    )संचालित द्वारा

ऊपर दिया गया कोड अपलोड किए गए PDF से एक हेल्पर फ़ंक्शन का उपयोग कर टेक्स्ट निकालता है। फिर यह तीन ड्रॉपडाउन दिखाता है: दो Qwen मॉडलों (या एप्लिकेशन के अनुसार किसी भी मॉडलों) के चयन के लिए, और एक रिस्पॉन्स के अधिकतम टोकन लिमिट के लिए।

नोट: टोकन लिमिट अधिकतम आउटपुट लंबाई को नियंत्रित करती है। जटिल या बहु-चरणीय रीजनिंग कार्यों के लिए, अधिक टोकन लिमिट सेट करने से मॉडल को पूरा उत्तर उत्पन्न करने में मदद मिलती है।

स्टेप 4.4: सबमिशन

इस स्टेप में मुख्य मॉडल तुलना लॉजिक लागू किया गया है। जब उपयोगकर्ता "Submit & Compare Models" पर क्लिक करता है, तो ऐप इनपुट वैलिडेट करता है, संदर्भ-सचेत प्रॉम्प्ट बनाता है, और चुने हुए मॉडलों को साइड-बाय-साइड क्वेरी करता है।

st.markdown("---")
col_btn1, col_btn2, col_btn3 = st.columns([1, 2, 1])
with col_btn2:
    if st.button("Submit & Compare Models", type="primary", use_container_width=True):
        if not user_question and not uploaded_pdf:
            st.warning(" Please enter a question or upload a PDF.")
        else:
            if context:
                base_prompt = f"DOCUMENT:\n{context}\n\nQUESTION: {user_question or 'Summarize the above document.'}"
            else:
                base_prompt = user_question
            prompt = f"""Please provide a detailed and thorough response. Think step by step and explain your reasoning clearly.
{base_prompt}
Please provide a comprehensive answer with clear reasoning and examples where appropriate."""           
            st.markdown("### Results")
            col_left, col_right = st.columns(2)
            models_to_process = [(model1, col_left, "Model A"), (model2, col_right, "Model B")]          
            for model_key, col, model_label in models_to_process:
                with col:
                    st.markdown(f'<div class="model-header">{model_label}: {model_key}</div>', unsafe_allow_html=True)                   
                    progress_bar = st.progress(0)
                    status_text = st.empty()                    
                    try:
                        progress_bar.progress(25)
                        status_text.text("Initializing model...")
                        model_info = MODEL_CONFIG[model_key]
                        vram_estimate = estimate_vram(
                            model_info["params_billion"], 
                            active_params_billion=model_info["active_params_billion"]
                        )
                        progress_bar.progress(50)
                        status_text.text("Querying model...")
                        result = query_openrouter(model_info["id"], prompt, max_tokens=max_tokens)                        
                        progress_bar.progress(100)
                        status_text.text("Complete!")
                        if "error" in result:
                            st.error(f"Error: {result['error']}")
                        else:
                            st.markdown(f'''
                            <div class="metric-card">
                                <strong>Performance Metrics</strong><br>
                                <strong>Latency:</strong> {result['latency']:.2f}s<br>
                                <strong>Speed:</strong> {result['tokens_per_sec']:.2f} tokens/sec<br>
                                <strong>Output tokens:</strong> {result['output_tokens']}<br>
                                <strong>Prompt tokens:</strong> {result['prompt_tokens']}<br>
                                <strong>Est. VRAM:</strong> {vram_estimate} GB
                            </div>
                            ''', unsafe_allow_html=True)
                            st.markdown("** Response:**")
                            st.markdown(f'''
                            <div class="output-box">
                                {result["output"] if result["output"] else "<em>No output received</em>"}
                            </div>
                            ''', unsafe_allow_html=True)                
                    except Exception as e:
                        st.error(f" Unexpected error: {str(e)}")                    
                    finally:
                        progress_bar.empty()
                        status_text.empty()            
            st.markdown("---")            संचालित द्वारा

सबमिशन हैंडलर बेंचमार्किंग वर्कफ़्लो को इस प्रकार व्यवस्थित करता है: 

• जब उपयोगकर्ता "Submit & Compare Models" पर क्लिक करता है, ऐप जाँचता है कि कोई प्रश्न या PDF दिया गया है या नहीं—और यदि नहीं, तो चेतावनी देता है।
• इसके बाद, यह दस्तावेज़ संदर्भ और उपयोगकर्ता प्रश्न से प्रॉम्प्ट बनाता है, और विस्तृत, चरण-दर-चरण उत्तरों के लिए निर्देश जोड़ता है।
• रिज़ल्ट क्षेत्र को दो कॉलम में बाँटा जाता है ताकि मॉडल आउटपुट की सीधी, साइड-बाय-साइड तुलना हो सके।
• हर मॉडल के लिए, यह एक प्रोग्रेस बार दिखाता है, VRAM उपयोग का अनुमान लगाता है, OpenRouter API को क्वेरी करता है, और अनुरोध प्रोसेस होने के दौरान स्टेटस संदेश अपडेट करता है।
• पूरा होने पर, ऐप कार्ड्स में लेटेंसी, प्रति सेकंड टोकन, टोकन काउंट, और VRAM उपयोग जैसे प्रदर्शन मेट्रिक्स दिखाता है।

Qwen3-Next का परीक्षण

Qwen3-Next मॉडल के वास्तविक प्रदर्शन को परखने के लिए, मैंने कुछ प्रयोग किए।

टेस्ट 1: लंबा कॉन्टेक्स्ट Q&A

Qwen3-Next की लंबा कॉन्टेक्स्ट क्षमता का मूल्यांकन करने के लिए, मैंने Project Gutenberg eBook “War and Peace” पर कई हैंड्स-ऑन प्रयोग किए—यह अब तक लिखे गए सबसे लंबे और जटिल उपन्यासों में से एक है।

नीचे तीन टेस्ट केस हैं जो दिखाते हैं कि मॉडल अल्ट्रा-लॉन्ग कॉन्टेक्स्ट को कैसे संभालते हैं, मतिभ्रम (हैलुसिनेशन) से कैसे बचते हैं, और उच्च-गुणवत्ता का सारांश कैसे देते हैं।

किरदारों की ट्रैकिंग 

सबसे पहले, मैंने दोनों मॉडलों से कहा कि वे उन सभी मुख्य किरदारों की पहचान करें जो उपन्यास के पहले और आखिरी अध्याय, दोनों में दिखाई देते हैं, और संक्षेप में बताएँ कि कहानी के दौरान उनकी भूमिकाएँ कैसे बदलती हैं।

प्रॉम्प्ट: “उपन्यास के पहले और आखिरी अध्याय दोनों में आने वाले सभी मुख्य किरदारों की सूची दें। संक्षेप में बताएँ कि समय के साथ उनकी भूमिकाएँ कैसे बदलती हैं।”

यह प्रश्न मॉडल से पूर्ण टेक्स्ट प्रोसेस करने और किरदारों के आर्क्स को सटीक रूप से ट्रैक करने की मांग करता है। दोनों मॉडल अत्यंत प्रतिक्रियाशील थे, लेकिन Qwen3 Next का उत्तर अधिक साफ़-सुथरा था और किताब के प्रत्येक अध्याय के अनुरूप बेहतर ढंग से ट्यून किया हुआ था।

हैलुसिनेशन टेस्ट

इसके बाद, मैं देखना चाहता था कि क्या मॉडल वास्तविक कंटेंट और ग़लत जानकारी में फर्क कर सकते हैं। मैंने दोनों मॉडलों को एक ऐसा वाक्यांश दिया जो War and Peace में नहीं आता, लेकिन टॉल्स्टॉय के एक अन्य प्रसिद्ध उपन्यास से है।

प्रॉम्प्ट: “क्या उपन्यास में यह वाक्यांश आता है—‘All happy families are alike; each unhappy family is unhappy in its own way’? अगर हाँ, तो टेक्स्ट में यह कहाँ आता है?”

यह वाक्यांश वास्तव में Anna Karenina से है, War and Peace से नहीं। एक आदर्श मॉडल को “नहीं” में उत्तर देना चाहिए—जो मजबूत तथ्यात्मक शुद्धता और कम हैलुसिनेशन दिखाता है। प्रभावशाली रूप से, Qwen3-Next ने सही उत्तर दिया, जबकि Qwen3 30B मॉडल ने एक गलत वाक्यांश के साथ जवाब दिया।

सारांशण

अंत में, मैंने दोनों मॉडलों की सारांशण क्षमता को 300 शब्दों में उपन्यास का सार देने के लिए कहकर परखा।

प्रॉम्प्ट: “‘War and Peace’ का 300 शब्दों में सारांश दें, Pierre Bezukhov की व्यक्तिगत यात्रा पर फोकस करते हुए।”

हालाँकि सारांश का मूल्यांकन आंशिक रूप से व्यक्तिपरक होता है, मुझे Qwen3-Next का आउटपुट अधिक संरचित, सुसंगत, और सूझबूझ भरा लगा। सार न केवल संक्षिप्त था बल्कि उसने Pierre के चरित्र-विकास को स्पष्टता के साथ पकड़ा।

उदाहरण 2: मल्टी-स्टेप रीजनिंग और लॉजिक

दोनों मॉडलों की उन्नत रीजनिंग क्षमताओं को परखने के लिए, मैंने उन्हें जटिल, मल्टी-स्टेप लॉजिक पज़ल्स दिए—ऐसे कार्य जो केवल मेमोरी ही नहीं, बल्कि चरणबद्ध निष्कर्ष और सावधानीपूर्वक उन्मूलन की मांग करते हैं।

सीटिंग अरेंजमेंट लॉजिक पज़ल

सबसे पहले, मैंने मॉडलों को एक सीटिंग अरेंजमेंट ब्रेनटीज़र दिया:

प्रॉम्प्ट: “वेडिंग रिसेप्शन में पाँच मेहमान—Colin, Emily, Kate, Fred, और Irene—डिनर टेबल पर कहाँ बैठें, इसे लेकर असमंजस में हैं। वे दुल्हन की माँ से पूछते हैं, जो कहती हैं, "जहाँ तक मुझे याद है, Colin Kate के बगल में नहीं है, Emily Fred या Kate के पास नहीं है। न Kate, न Emily—दोनों Irene के पास नहीं हैं। और Fred को Irene के बाएँ बैठना चाहिए।" टेबल के दूसरी ओर से देखते हुए, क्या आप बाएँ से दाएँ मेहमानों को सही क्रम में बैठा सकते हैं?

अपनी तर्क-प्रक्रिया चरण-दर-चरण समझाएँ।”

इस पज़ल में कई बाधाओं का विश्लेषण करके एकमात्र संभावित सीटिंग क्रम निकालना था:

• ग्राउंड ट्रुथ: Emily, Colin, Irene, Fred, Kate
• Qwen3-Next आउटपुट: Kate, Fred, Irene, Colin, Emily (लगभग सही, पर उल्टा)
• Qwen3-30B आउटपुट: मान्य उत्तर खोजने में असमर्थ

हालाँकि कोई भी मॉडल बिल्कुल सही क्रम तक नहीं पहुँचा, Qwen3-Next बहुत करीब था—सिर्फ क्रम उल्टा कर दिया—जबकि 30B मॉडल बिल्कुल समाधान तक नहीं पहुँचा। यह दर्शाता है कि Qwen3-Next मल्टी-स्टेप निष्कर्ष निकालने में सक्षम है, भले ही कुछ एज केस चुनौतीपूर्ण रहें।

निष्कर्षात्मक उन्मूलन 

इसके बाद, मैंने मॉडलों को क्लासिक “Zebra puzzle” से प्रेरित एक डिडक्शन पज़ल से परखा।

प्रॉम्प्ट: “चार लोग (Lisa, Mike, Nora, और Omar) ने प्रत्येक ने अलग फल (apple, banana, cherry, date) खरीदा और अलग कार (Ford, Honda, Kia, Mazda) चलाई।

• Lisa ने banana नहीं खरीदा।
• Ford चलाने वाले ने cherry खरीदा।
• Mike ने Honda चलाई।
• Nora ने apple खरीदा और Mazda नहीं चलाई।
• Kia चलाने वाले ने date खरीदा।
• Omar ने Ford नहीं चलाई।

किसने कौन-सा फल खरीदा और कौन-सी कार चलाई? अपना कार्य-प्रदर्शन दिखाएँ।”

यह समस्या जानबूझकर दी गई बाधाओं के साथ असमाधेय है, लेकिन मॉडलों ने इसके बजाय यह लौटाया:

• Qwen3-Next आउटपुट: इसने सही पहचाना कि कोई मान्य असाइनमेंट मौजूद नहीं है।
• Qwen3-30B आउटपुट: यह एक लॉजिकल लूप में फँस गया और दिए गए आउटपुट टोकन में निष्कर्ष तक नहीं पहुँच सका।

यह उदाहरण दिखाता है कि Qwen3-Next निष्कर्षात्मक रूप से तर्क कर सकता है और यह पहचान सकता है कि कब कोई समाधान संभव नहीं है।

निष्कर्ष

यह ट्यूटोरियल दिखाता है कि Qwen3-Next-80B-A3B का उपयोग Q&A और रीजनिंग टास्क्स के लिए कैसे करें, और एक साइड-बाय-साइड Streamlit ऐप में इसे Qwen3-30B-A3B के साथ कैसे बेंचमार्क करें। परिणाम बताते हैं कि Qwen3-Next अल्ट्रा-लॉन्ग डॉक्युमेंट्स को संभालने, तेज़ इंफेरेंस देने, और जटिल रीजनिंग समस्याओं पर भी आउटपुट गुणवत्ता बनाए रखने में सक्षम है।