क्वांटाइज़ेशन-अवेयर ट्रेनिंग: Gemma 4 की लोकल इन्फ़रेंस सुधारने की गाइड

क्वांटाइज़ेशन क्या है?

क्वांटाइज़ेशन एक मोडल संपीड़न तकनीक है जो मॉडल वेट्स की प्रिसिशन को घटाती है। 

बड़े भाषा मॉडल आमतौर पर BF16 या FP16 जैसे उच्च-प्रिसिशन फ़ॉर्मैट में स्टोर किए जाते हैं, जो गुणवत्ता बनाए रखते हैं लेकिन अधिक मेमोरी माँगते हैं। क्वांटाइज़ेशन इन वेट्स को 8-बिट या 4-बिट जैसे लोअर-बिट फ़ॉर्मैट में बदल देता है, जिससे मॉडल कम VRAM का उपयोग करता है और लोकल रूप से अधिक आसानी से चलता है। Hugging Face बताता है कि 8-बिट क्वांटाइज़ेशन मेमोरी उपयोग को लगभग आधा कर सकता है, जबकि 4-बिट इसे और भी कम कर सकता है।

समझौता यह है कि कम प्रिसिशन कभी-कभी आउटपुट गुणवत्ता घटा सकती है, खासकर यदि मॉडल क्वांटाइज़ेशन के लिए अनुकूलित न हो। सरल शब्दों में, BF16 और FP16 आमतौर पर सर्वश्रेष्ठ गुणवत्ता देते हैं लेकिन अधिक मेमोरी लेते हैं; 8-बिट मॉडल छोटे होते हैं और प्रायः अच्छी गुणवत्ता बनाए रखते हैं, और 4-बिट मॉडल बहुत छोटे होते हैं पर कुछ एक्युरेसी या स्थिरता खो सकते हैं। 

लोकल इन्फ़रेंस के लिए, यह समझौता अक्सर फ़ायदेमंद होता है क्योंकि यह बड़े मॉडलों को महंगे डेटा सेंटर हार्डवेयर के बजाय कंज़्यूमर GPUs पर चलाने देता है।

क्वांटाइज़ेशन-अवेयर ट्रेनिंग क्या है?

क्वांटाइज़ेशन-अवेयर ट्रेनिंग (QAT) एक ट्रेनिंग तकनीक है जिसमें मॉडल को कम-प्रिसिशन व्यवहार का सिमुलेशन करते हुए ट्रेन या फ़ाइन-ट्यून किया जाता है। यह मॉडल को क्वांटाइज़ेशन के बाद अधिक स्थिर रहने में मदद करता है और लो-बिट चौड़ाइयों पर लोकल इन्फ़रेंस प्रदर्शन में सुधार ला सकता है।

QAT अलग कैसे है?

सामान्य तरीका, पोस्ट-ट्रेनिंग क्वांटाइज़ेशन, मॉडल को ट्रेन होने के बाद संपीड़ित करता है। यह सरल और व्यावहारिक है, लेकिन मॉडल कुछ गुणवत्ता खो सकता है क्योंकि उसे कम-प्रिसिशन वेट्स सँभालने के लिए प्रशिक्षित नहीं किया गया था। 

Google AI Edge के दस्तावेज़ों के अनुसार, पोस्ट-ट्रेनिंग क्वांटाइज़ेशन एक कन्वर्ज़न स्टेप है जो मॉडल आकार घटा सकता है और लेटेंसी सुधार सकता है, आम तौर पर थोड़ी-सी एक्युरेसी हानि के साथ। हालाँकि, अंतिम गुणवत्ता फिर भी मॉडल और क्वांटाइज़ेशन स्तर पर निर्भर कर सकती है। 

क्वांटाइज़ेशन-अवेयर ट्रेनिंग, या QAT, इक अलग तरीका अपनाता है। केवल ट्रेनिंग के बाद क्वांटाइज़ करने के बजाय, QAT ट्रेनिंग या फ़ाइन-ट्यूनिंग के दौरान ही कम-प्रिसिशन व्यवहार का सिमुलेशन करता है। यह मॉडल को सिखाता है कि बाद में छोटे फ़ॉर्मैट में कन्वर्ट होने पर कैसे स्थिर रहना है। यह मॉडल को कंप्रेस करने पर गुणवत्ता हानि को न्यूनतम करता है।

इसी कारण Gemma 4 QAT लोकल AI के लिए उपयोगी है। इसे क्वांटाइज़ेशन को ध्यान में रखकर बनाया गया है, इसलिए यह कम मेमोरी का उपयोग करते हुए मूल मॉडल की अधिक गुणवत्ता बनाए रख सकता है। कंज़्यूमर GPUs पर मॉडल चलाने वाले उपयोगकर्ताओं के लिए, इसका अर्थ बेहतर लो-बिट स्थिरता, कम VRAM उपयोग, और अधिक व्यावहारिक लोकल इन्फ़रेंस हो सकता है।

चरण 1: डिपेंडेंसी इंस्टॉल करें और llama.cpp बिल्ड करें

मॉडलों को डाउनलोड करने से पहले, हमें लोकल रनटाइम तैयार करना होगा। यह ट्यूटोरियल NVIDIA RTX 4090 GPU और 24 GB VRAM वाली मशीन पर परीक्षण किया गया था। हम इन्फ़रेंस रनटाइम के रूप में llama.cpp, मॉडल फ़ॉर्मैट के रूप में GGUF, और UD-Q4_K_XL क्वांटाइज़्ड मॉडल फ़ाइलों का उपयोग करेंगे।

परीक्षित सेटअप:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• रनटाइम: llama.cpp
• मॉडल फ़ॉर्मैट: GGUF
• क्वांटाइज़ेशन: UD-Q4_K_XL

हम निम्नलिखित दो Unsloth GGUF मॉडलों की तुलना करेंगे:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

पहले, जाँच लें कि आपका GPU उपलब्ध है।

nvidia-smiसंचालित द्वारा

अगला, llama.cpp को बिल्ड करने के लिए आवश्यक सिस्टम पैकेज इंस्टॉल करें।

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -yसंचालित द्वारा

आधिकारिक llama.cpp रिपोजिटरी को क्लोन करें।

git clone https://github.com/ggml-org/llama.cppसंचालित द्वारा

अब CUDA सपोर्ट सक्षम करके llama.cpp बिल्ड करें। इससे मॉडल लेयर्स केवल CPU पर नहीं, GPU पर चल सकेंगी।

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ONसंचालित द्वारा

आवश्यक बाइनरी कम्पाइल करें।

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-splitसंचालित द्वारा

बिल्ड पूरा होने के बाद, मुख्य बाइनरी जिसका हम उपयोग करेंगे वह है llama-server। यह हमें GGUF मॉडल को लोकल रूप से चलाने देता है और एक OpenAI-संगत API एन्डपॉइंट उपलब्ध कराता है, जिसे हम curl से क्वेरी कर सकते हैं। 

चरण 2: Gemma 4 12B के Non-QAT और QAT मॉडल डाउनलोड करें 

अब जब llama.cpp तैयार है, हम Hugging Face से Gemma 4 12B मॉडल के दोनों वेरिएंट डाउनलोड कर सकते हैं। हम रेगुलर इंस्ट्रक्शन-ट्यून मॉडल और QAT संस्करण को GGUF फ़ॉर्मैट में डाउनलोड करेंगे।

सबसे पहले, तेज़ डाउनलोड सपोर्ट के साथ Hugging Face Hub CLI इंस्टॉल करें।

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transferसंचालित द्वारा

हाई-परफ़ॉर्मेंस Xet डाउनलोड सक्षम करें।

export HF_XET_HIGH_PERFORMANCE=1संचालित द्वारा

GGUF फ़ॉर्मैट में रेगुलर Gemma 4 12B इंस्ट्रक्शन मॉडल डाउनलोड करें।

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"संचालित द्वारा

अगला, उसी क्वांटाइज़ेशन फ़ॉर्मैट का उपयोग करके QAT संस्करण डाउनलोड करें।

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"संचालित द्वारा

--include फ़्लैग यह सुनिश्चित करते हैं कि हम पूरे रिपोजिटरी को खींचने के बजाय केवल इस ट्यूटोरियल के लिए आवश्यक फ़ाइलें ही डाउनलोड करें। यहाँ, हम UD-Q4_K_XL GGUF मॉडल फ़ाइलें और mmproj-BF16 फ़ाइलें डाउनलोड कर रहे हैं जिनका उपयोग मॉडल पैकेज करता है। 

डाउनलोड पूरा होने के बाद, सुनिश्चित करें कि दोनों मॉडल फ़ोल्डर मौजूद हैं।

ls modelsसंचालित द्वारा

अपेक्षित आउटपुट:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUFसंचालित द्वारा

इस समय, non-QAT और QAT दोनों मॉडल लोकल रूप से उपलब्ध हैं, और हम उन्हें llama-server से सर्व करना शुरू कर सकते हैं।

चरण 3: llama-server के साथ Non-QAT मॉडल चलाएँ

हम रेगुलर Gemma 4 12B इंस्ट्रक्शन मॉडल चलाकर शुरू करेंगे। इससे हमें एक बेसलाइन मिलेगी ताकि बाद में हम समान सेटिंग्स के साथ QAT संस्करण की तुलना कर सकें।

non-QAT मॉडल को llama-server के साथ शुरू करें।

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64संचालित द्वारा

यह http://localhost:8001 पर एक लोकल OpenAI-संगत सर्वर शुरू करता है।

एक और टर्मिनल खोलें और लोकल सर्वर पर अनुरोध भेजें।

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'संचालित द्वारा

इस कमांड में, हम लोकल /v1/chat/completions एन्डपॉइंट का उपयोग कर रहे हैं, जो OpenAI-संगत API फ़ॉर्मैट का पालन करता है। प्रॉम्प्ट मॉडल से क्वांटाइज़ेशन-अवेयर ट्रेनिंग समझाने के लिए कहता है, और max_tokens को 512 पर सेट किया गया है ताकि दोनों मॉडल वेरिएंट समान आउटपुट लंबाई के साथ परखे जा सकें। 

हमारे RTX 4090 परीक्षण में, non-QAT मॉडल ने निम्नलिखित टाइमिंग परिणाम दिए:

• प्रॉम्प्ट टोकन: 40
• कम्प्लीशन टोकन: 512
• प्रॉम्प्ट स्पीड: 510.22 टोकन/सेकंड
• जनरेशन स्पीड: 94.65 टोकन/सेकंड
• कुल समय: 5.516 सेकंड

GPU मेमोरी उपयोग:

9247 MiB / 24564 MiB

यह हमें रेगुलर Gemma 4 12B मॉडल का बेसलाइन प्रदर्शन देता है। अगले चरण में, हम समान कॉन्फ़िगरेशन के साथ QAT संस्करण चलाएँगे और परिणामों की तुलना करेंगे।

चरण 4: QAT मॉडल चलाएँ और जाँचें

अब हम समान llama-server सेटिंग्स के साथ Gemma 4 12B का QAT संस्करण चलाएँगे। इस सर्वर को शुरू करने से पहले, सुनिश्चित करें कि आप पिछला non-QAT सर्वर रोक दें, क्योंकि दोनों कमांड एक ही पोर्ट का उपयोग करते हैं।

QAT मॉडल शुरू करें।

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64संचालित द्वारा

यह QAT मॉडल को उसी लोकल OpenAI-संगत एन्डपॉइंट http://localhost:8001 पर शुरू करता है।

अब वही टेस्ट प्रॉम्प्ट QAT मॉडल को भेजें।

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'संचालित द्वारा

हमारे RTX 4090 परीक्षण में, QAT मॉडल ने निम्नलिखित टाइमिंग परिणाम दिए:

1. प्रॉम्प्ट टोकन: 40
2. कम्प्लीशन टोकन: 512
3. प्रॉम्प्ट स्पीड: 593.93 टोकन/सेकंड
4. जनरेशन स्पीड: 101.65 टोकन/सेकंड
5. कुल समय: 5.114 सेकंड

GPU मेमोरी उपयोग:

8627 MiB / 24564 MiB

आप लोकल सर्वर URL (http://localhost:8001) कॉपी करके अपने ब्राउज़र में भी पेस्ट कर सकते हैं:

यह बिल्ट-इन llama.cpp वेब UI खोलता है, जो लोकल मॉडल की जाँच के लिए एक सरल ChatGPT-जैसा इंटरफ़ेस देता है। आप इसे ब्राउज़र में सीधे QAT मॉडल से चैट करने, प्रॉम्प्ट्स के साथ प्रयोग करने, और मॉडल का उपयोग एक दैनिक लोकल AI सहायक के रूप में करने के लिए उपयोग कर सकते हैं। 

QAT बनाम Non-QAT परिणामों की तुलना

दोनों मॉडलों को समान प्रॉम्प्ट और सर्वर सेटिंग्स के साथ परखने के बाद, हम RTX 4090 पर उनके प्रदर्शन की सीधी तुलना कर सकते हैं।

इस रन में, QAT मॉडल रेगुलर non-QAT मॉडल की तुलना में तेज़ और हल्का दोनों था। इसने 620 MiB कम VRAM का उपयोग किया, जिससे मेमोरी उपयोग लगभग 6.7% घटा। यह लोकल इन्फ़रेंस के लिए उपयोगी है क्योंकि कंज़्यूमर GPUs पर बड़े मॉडल चलाते समय बचाई गई हर VRAM मायने रखती है।

QAT मॉडल ने टोकन भी तेज़ी से जेनरेट किए, 94.65 टोकन/सेकंड से 101.65 टोकन/सेकंड तक सुधार हुआ। यह लगभग 7.4% की वृद्धि है, जिससे वॉल-क्लॉक समय 5.516 सेकंड से घटकर 5.114 सेकंड हो गया।

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

अंतिम विचार

Google लोकल AI समुदाय के लिए शानदार काम कर रहा है। Gemma 4 जैसे मॉडल और QAT जैसी तकनीकों के साथ, शक्तिशाली AI मॉडलों को पूरी तरह ऑफ़लाइन, और यहाँ तक कि कंज़्यूमर हार्डवेयर पर लोकल रूप से चलाने का सपना सच हो रहा है। 

सबसे उत्साहजनक बात यह है कि यह केवल मॉडल आकार घटाने के बारे में नहीं है। QAT के साथ, हम मॉडल को फिट कराने के लिए सिर्फ गुणवत्ता से समझौता नहीं कर रहे। हमें ऐसे मॉडल मिल रहे हैं जो लो-बिट फ़ॉर्मैट में बेहतर चलने के लिए डिज़ाइन किए गए हैं, जिससे समूचा लोकल AI अनुभव सुधरता है। इस परीक्षण में, QAT मॉडल non-QAT संस्करण की तुलना में तेज़, हल्का और उपयोग में स्मूद था।

मैं अब मॉडल के MTP संस्करण का परीक्षण करने के लिए उत्सुक हूँ, जो गति को और बढ़ा सकता है, संभवतः 2x तक। इससे मेरा अधिक कामकाज लोकल AI पर स्थानांतरित करना बहुत आसान हो जाएगा। मैं मॉडल को लोकल रूप से चला सकता हूँ, उसे OpenCode जैसे टूल्स से जोड़ सकता हूँ, और एक निजी लोकल असिस्टेंट के साथ सीधे प्रोजेक्ट फ़ाइलों को एडिट करना शुरू कर सकता हूँ।

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