Ollama के साथ QwQ 32B को लोकली सेट अप और रन कैसे करें

QwQ-32B Qwen का रीजनिंग मॉडल है, जिसे जटिल समस्या-समाधान और तर्क-आधारित कार्यों में उत्कृष्ट प्रदर्शन के लिए डिज़ाइन किया गया है। केवल 32 बिलियन पैरामीटर्स होने के बावजूद, यह मॉडल कहीं बड़े DeepSeek-R1 (671 बिलियन पैरामीटर्स) के तुलनीय प्रदर्शन हासिल करता है।

इस ट्यूटोरियल में, मैं आपको Ollama का उपयोग करके QwQ-32B को लोकली सेट अप और रन करने की प्रक्रिया बताऊँगा—यह एक ऐसा टूल है जो लोकल LLM इन्फ़रेंस को सरल बनाता है। इस गाइड में शामिल है: 

• टर्मिनल या IDE के माध्यम से निष्पादन: टर्मिनल या आपकी पसंद के IDE से QwQ-32B चलाने के लिए संक्षिप्त कोड स्निपेट्स।
• हैंड्स-ऑन डेमो: QwQ-32B की संरचित सोच क्षमताओं का उपयोग करने वाला एक डेमो प्रोजेक्ट बनाना।

QwQ-32B को लोकली क्यों चलाएँ?

इसके आकार के बावजूद, QwQ-32B को क्वांटाइज़ किया जा सकता है ताकि यह कंज़्यूमर हार्डवेयर पर कुशलता से चले। QwQ-32B को लोकली चलाने से आपको बाहरी सर्वरों पर निर्भर हुए बिना मॉडल निष्पादन पर पूरा नियंत्रण मिलता है। लोकली चलाने के कुछ लाभ इस प्रकार हैं:

• प्राइवेसी और सुरक्षा: आपका डेटा आपकी प्रणाली से बाहर नहीं जाता।
• अविरल पहुँच: रेट लिमिट, डाउनटाइम, या सेवा व्यवधानों से बचें।
• प्रदर्शन: API लेटेंसी से बचते हुए लोकल इन्फ़रेंस पर तेज़ प्रतिक्रिया पाएँ।
• कस्टमाइज़ेशन: पैरामीटर्स संशोधित करें, प्रॉम्प्ट्स फाइन-ट्यून करें, और मॉडल को लोकल ऐप्लिकेशंस में इंटिग्रेट करें।
• लागत-कुशलता: मॉडल को लोकली चलाकर API शुल्क समाप्त करें।
• ऑफ़लाइन उपलब्धता: एक बार मॉडल डाउनलोड हो जाने पर बिना इंटरनेट कनेक्शन के काम करें।

Ollama के साथ QwQ-32B को लोकली सेट अप करना

Ollama मॉडल डाउनलोड, क्वांटाइज़ेशन और निष्पादन संभालकर लोकली LLMs चलाना सरल बनाता है।

स्टेप 1: Ollama इंस्टॉल करें

Ollama को आधिकारिक वेबसाइट से डाउनलोड और इंस्टॉल करें। 

डाउनलोड पूरा होने के बाद, Ollama एप्लिकेशन को वैसे ही इंस्टॉल करें जैसे आप किसी अन्य एप्लिकेशन को करते हैं। 

स्टेप 2: QwQ-32B डाउनलोड करें और चलाएँ

अब सेटअप का परीक्षण करते हैं और अपना मॉडल डाउनलोड करते हैं। टर्मिनल लॉन्च करें और QwQ-32B मॉडल डाउनलोड और रन करने के लिए निम्न कमांड टाइप करें:

ollama run qwq:32b

QwQ-32B एक बड़ा मॉडल है। यदि आपके सिस्टम में संसाधन सीमित हैं, तो आप छोटे क्वांटाइज़्ड वर्ज़न्स चुन सकते हैं। उदाहरण के लिए, नीचे हम Q4_K_M वर्ज़न का उपयोग करते हैं, जो 19.85GB का मॉडल है और प्रदर्शन तथा आकार के बीच संतुलन बनाता है:

ollama run qwq:Q4_K_M

स्रोत: Hugging Face

और क्वांटाइज़्ड मॉडल आपको यहाँ मिल सकते हैं।

स्टेप 3: QwQ-32B को बैकग्राउंड में चलाना

QwQ-32B को निरंतर चलाने और API के माध्यम से सर्व करने के लिए, Ollama सर्वर शुरू करें:

ollama serve

इससे मॉडल ऐप्लिकेशंस के लिए उपलब्ध हो जाएगा, जिन पर अगला सेक्शन चर्चा करता है।

QwQ-32B को लोकली इस्तेमाल करना

अब जब QwQ-32B सेट अप हो गया है, तो देखते हैं इससे कैसे इंटरैक्ट करें।

स्टेप 1: CLI के जरिए इन्फ़रेंस चलाना

मॉडल डाउनलोड हो जाने के बाद, आप सीधे टर्मिनल में QwQ-32B मॉडल से इंटरैक्ट कर सकते हैं:

ollama run qwq
How many r's are in the word "strawberry”?

मॉडल की प्रतिक्रिया प्रायः उसका सोचने का उत्तर होती है (जिसे <think> </think> टैब्स में समाहित किया जाता है) और उसके बाद अंतिम उत्तर आता है।

स्टेप 2: API के माध्यम से QwQ-32B तक पहुँचना

एप्लिकेशंस में QwQ-32B को इंटिग्रेट करने के लिए, आप curl के साथ Ollama API का उपयोग कर सकते हैं। अपने टर्मिनल में नीचे दिया गया curl कमांड चलाएँ।

curl -X POST http://localhost:11434/api/chat -H "Content-Type: application/json" -d '{
  "model": "qwq",
  "messages": [{"role": "user", "content": "Explain Newton second law of motion"}], 
  "stream": false
}'

curl एक कमांड-लाइन टूल है जो Linux में नेटिव है और macOS पर भी काम करता है। यह उपयोगकर्ताओं को सीधे टर्मिनल से HTTP अनुरोध भेजने देता है, जिससे APIs के साथ इंटरैक्ट करना सुविधाजनक हो जाता है।

नोट: dquote त्रुटियों से बचने के लिए उद्धरण चिह्नों का सही उपयोग करें और सही localhost पोर्ट चुनें।

स्टेप 3: Python के साथ QwQ-32B चलाना

हम किसी भी एकीकृत विकास परिवेश (IDE) में Ollama चला सकते हैं। आप निम्न कोड का उपयोग करके Ollama का Python पैकेज इंस्टॉल कर सकते हैं: 

pip install ollama

Ollama इंस्टॉल होने के बाद, मॉडल से इंटरैक्ट करने के लिए निम्न स्क्रिप्ट का उपयोग करें:

import ollama
response = ollama.chat(
    model="qwq",
    messages=[
        {"role": "user", "content": "Explain Newton's second law of motion"},
    ],
)
print(response["message"]["content"])

फ़ंक्शन ollama.chat() मॉडल का नाम और उपयोगकर्ता का प्रॉम्प्ट लेता है और उसे एक वार्तालाप के रूप में संसाधित करता है। स्क्रिप्ट फिर मॉडल की प्रतिक्रिया निकालकर प्रिंट करती है।

QwQ-32B के साथ लोकली एक Logical Reasoning ऐप चलाना

हम QwQ-32B और Gradio का उपयोग करके एक साधारण लॉजिकल रीजनिंग असिस्टेंट बना सकते हैं, जो उपयोगकर्ता द्वारा दर्ज प्रश्नों को स्वीकार करेगा और संरचित, तार्किक प्रतिक्रियाएँ जनरेट करेगा। यह ऐप QwQ-32B के क्रमबद्ध सोचने के तरीके का उपयोग करके स्पष्ट और सुविचारित उत्तर देगा—जो समस्या-समाधान, ट्यूटोरिंग और AI-सहायता प्राप्त निर्णय-निर्माण के लिए उपयोगी है।

स्टेप 1: पूर्वापेक्षाएँ

इम्प्लीमेंटेशन शुरू करने से पहले, सुनिश्चित करें कि हमारे पास निम्नलिखित टूल्स और लाइब्रेरीज़ इंस्टॉल हैं:

• Python 3.8+
• Gradio: यूज़र-फ्रेंडली वेब इंटरफ़ेस बनाने के लिए।
• Ollama: मॉडल्स तक लोकली पहुँचने की लाइब्रेरी

आवश्यक डिपेंडेंसियाँ इंस्टॉल करने के लिए निम्न कमांड्स चलाएँ:

pip install gradio ollama

ऊपर दी गई डिपेंडेंसियाँ इंस्टॉल होने के बाद, निम्न इम्पोर्ट कमांड्स चलाएँ:

import gradio as gr
import ollama
import re

स्टेप 2: Ollama का उपयोग करके QwQ 32B को क्वेरी करना

अब जबकि हमारी डिपेंडेंसियाँ तैयार हैं, हम एक क्वेरी फ़ंक्शन बनाएँगे जो हमारे प्रश्न को मॉडल तक पहुँचाएगा और एक संरचित प्रतिक्रिया प्राप्त करेगा।

def query_qwq(question):
    response = ollama.chat(
        model="qwq",
        messages=[{"role": "user", "content": question}]
    )
    full_response = response["message"]["content"]
    # Extract the <think> part and the final answer
    think_match = re.search(r"<think>(.*?)</think>", full_response, re.DOTALL)
    think_text = think_match.group(1).strip() if think_match else "Thinking process not explicitly provided."
    final_response = re.sub(r"<think>.*?</think>", "", full_response, flags=re.DOTALL).strip()
    return think_text, final_response

फ़ंक्शन query_qwq() Ollama के माध्यम से Qwen QwQ-32B मॉडल से इंटरैक्ट करता है—यह उपयोगकर्ता द्वारा दिया गया प्रश्न भेजता है और एक संरचित प्रतिक्रिया प्राप्त करता है। यह दो प्रमुख घटक निकालता है:

1. सोचने की प्रक्रिया: इसमें मॉडल के तर्क के चरण शामिल होते हैं (जो <think>...</think> टैग्स से निकाले जाते हैं)।
2. अंतिम प्रतिक्रिया:  तर्क के बाद का संरचित अंतिम उत्तर। (जिसमें <think> सेक्शन शामिल नहीं होता)

यह तर्क-चरण और अंतिम प्रतिक्रिया को अलग-अलग प्रस्तुत करता है, जिससे यह स्पष्ट होता है कि मॉडल अपने निष्कर्षों तक कैसे पहुँचा।

स्टेप 3: Gradio इंटरफ़ेस बनाना

अब जब हमारा कोर फ़ंक्शन तैयार है, हम Gradio UI बनाएँगे।

interface = gr.Interface(
    fn=query_qwq,
    inputs=gr.Textbox(label="Ask a logical reasoning question"),
    outputs=[gr.Textbox(label="Thinking Process"), gr.Textbox(label="Final Response")],
    title="QwQ-32B Powered: Logical Reasoning Assistant",
    description="Ask a logical reasoning question and the assistant will provide an explanation."
)
interface.launch(debug = True)

यह Gradio इंटरफ़ेस एक लॉजिकल रीजनिंग असिस्टेंट सेट करता है जो gr.Textbox() फ़ंक्शन के माध्यम से उपयोगकर्ता का प्रश्न लेता है और query_qwq() फ़ंक्शन से उसे प्रोसेस करता है। अंत में, interface.launch() फ़ंक्शन डिबगिंग सक्षम के साथ Gradio ऐप शुरू करता है, जिससे त्रुटि ट्रैकिंग और लॉग्स रीयल-टाइम में मिलते हैं।

निष्कर्ष

Ollama के साथ QwQ-32B को लोकली चलाने से निजी, तेज़ और किफ़ायती मॉडल इन्फ़रेंस संभव होता है। इस ट्यूटोरियल के साथ, आप इसकी उन्नत तर्क-क्षमताओं को रीयल-टाइम में खोज सकते हैं। इस मॉडल का उपयोग AI-सहायता प्राप्त ट्यूटोरिंग, लॉजिक-आधारित समस्या-समाधान, और अन्य अनुप्रयोगों में किया जा सकता है।