विषय-सूची

आप कोई local LLM चलाने के लिए Hugging Face खोलते हैं, और वही मॉडल फ़ाइलों की एक दीवार के साथ दिखता है—Q4_K_M, Q5_K_S, GPTQ, AWQ, IQ3_M… और आप जड़ हो जाते हैं। यही पहली दीवार है जिससे ज़्यादातर लोग टकराते हैं। यह लेख व्यावहारिक रूप से इसका जवाब देता है, "इसे चलाने के लिए मैं कौन-सी क्वांटाइज़्ड फ़ाइल डाउनलोड करूँ?" हम क्वांटाइज़ेशन क्या है (अवधारणा) को दूसरे लेख के लिए छोड़ते हैं और यहाँ फ़ॉर्मैट चुनने पर ध्यान देते हैं।

हम इन्हें कवर करेंगे: फ़ॉर्मैट रनटाइम से क्यों तय होता है, GGUF की नामकरण योजना (Q4_K_M), 4 फ़ॉर्मैट की तुलना, बिट-डेप्थ कैसे चुनें, और फ़ाइलें कैसे ढूँढें। मुख्य बातें पहले ही। ① फ़ॉर्मैट ज़्यादातर इससे तय होता है कि "आप इसे किस इंजन पर चलाएँगे" (GGUF = llama.cpp / Ollama; GPTQ / AWQ = vLLM जैसे GPU इंजन)। ② Q4_K_M का मतलब है "4-bit, K-quant, साइज़ M"—ज़्यादातर मामलों में आम स्वीट स्पॉट। ③ संशय हो तो Q4_K_M से शुरू करें; VRAM हो तो Q5/Q6 तक बढ़ें।

QUANTIZATION FORMATS

फ़ॉर्मैट रनटाइम से तय होता है

— पहले इंजन तय करें, और फ़ाइल का चुनाव तेज़ी से सिमट जाता है

GGUF llama.cpp / Ollama / LM Studio = CPU, Mac, आंशिक-GPU भी (एकमात्र CPU-अनुकूल)
GPTQ vLLM / TGI / ExLlama = GPU (कैलिब्रेशन ज़रूरी)
AWQ vLLM / TGI = GPU (activations के ज़रिए अहम वेट्स की रक्षा)
EXL2 ExLlamaV2 = GPU (बारीक बिट-चौड़ाई)

तो पहला सवाल है "मैं इसे किस इंजन पर चलाऊँगा?" CPU/Mac पर लोकल → GGUF. रफ़्तार के लिए GPU सर्वर → GPTQ / AWQ.

1. क्वांटाइज़्ड फ़ाइलें क्यों उलझन में डालती हैं

क्वांटाइज़ेशन का मतलब है आकार और मेमोरी घटाने के लिए मॉडल के वेट्स को कम बिट्स में राउंड करना (देखें क्वांटाइज़ेशन क्या है)। पेच यह है कि उस राउंडिंग के लिए कई तरीके (फ़ॉर्मैट) मौजूद हैं, और हर एक में बिट-डेप्थ और बारीकी के हिसाब से कई विविधताएँ होती हैं। नतीजा: Hugging Face पर एक मॉडल के नीचे 20 से ज़्यादा फ़ाइलें।

पर घबराएँ नहीं—यह चुनाव आसान हो जाता है जब आप इसे दो चरणों में बाँटते हैं: ① कौन-सा फ़ॉर्मैट (= आप इसे किस इंजन पर चलाएँगे), फिर ② उसके भीतर कौन-सी बिट-डेप्थ फ़ाइल। इसी क्रम में सोचें।

2. मुख्य नियम: फ़ॉर्मैट रनटाइम से तय होता है

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

फ़ॉर्मैटमुख्य इंजनहार्डवेयरकैलिब्रेशन
GGUFllama.cpp / Ollama / LM Studio / KoboldCppCPU, Mac, आंशिक-GPU (मिश्रित)वैकल्पिक (imatrix)
GPTQGPTQModel (पहले AutoGPTQ) / vLLM / TGI / ExLlamaGPUज़रूरी
AWQAutoAWQ / vLLM / TGIGPUज़रूरी
EXL2 / EXL3ExLlamaV2 / ExLlamaV3GPUज़रूरी
bitsandbytes (NF4/INT8)Transformers (लोड पर क्वांटाइज़ करता है)GPUकोई नहीं (डेटा-फ़्री)

एक बात याद रखें: GGUF एकमात्र ऐसा "लोकल सब-कुछ" फ़ॉर्मैट है जो CPU / Mac / आंशिक-GPU पर चलता है; बाकी (GPTQ / AWQ / EXL2) मूलतः GPU-केवल हैं। तो—

  • अपने PC / Mac / CPU पर चलाना (Ollama या LM Studio) → GGUF, बिना किसी मुक़ाबले के।
  • GPU सर्वर पर हाई थ्रूपुट (vLLM/TGI कई रिक्वेस्ट सर्व करते हुए) → GPTQ या AWQ।
  • एक ही GPU पर बिट-चौड़ाई बारीकी से घटाना → EXL2/EXL3।
  • Transformers में झटपट टेस्ट (पहले से क्वांटाइज़्ड फ़ाइल नहीं) → bitsandbytes (NF4)।

3. GGUF नामों को समझना (Q4_K_M)

GGUF, जिससे लोकल उपयोग में आपका सबसे ज़्यादा सामना होगा, तब निरापद हो जाता है जब आप फ़ाइलनाम में छिपे "कूट" को पढ़ सकें। Q4_K_M तीन हिस्सों से बना है।

Q4_K_M
Q4
बिट-डेप्थ (नाममात्र) = 4-bit. बड़ा अंक = ज़्यादा गुणवत्ता, बड़ी फ़ाइल।
K
K-quant (सुपर-ब्लॉक्स पर स्मार्ट क्वांटाइज़ेशन)। साधारण / _0 / _1 पुराने (legacy) हैं।
M
S/M/L = small/medium/large. कुछ अहम टेंसर्स को कितना ऊँची बिट्स में "अपग्रेड" किया जाता है।

तो Q4_K_M = "4-bit K-quant, साइज़ M (गुणवत्ता बचाने के लिए कुछ टेंसर्स अपग्रेड)।" असरदार बिट्स लेबल से थोड़ी ऊपर चलती हैं (जैसे Q4_K ≈ 4.5 bpw)।

दो और शब्द आपको भटकने से बचाते हैं।

  • IQ परिवार (IQ2_XS, IQ3_M आदि) = I-quants: एक नई, codebook-आधारित शृंखला जो उसी बिट-डेप्थ पर और भी छोटी हो सकती है। पर इनका इन्फ़रेंस भारी होता है, और इन्हें व्यावहारिक रूप से नीचे बताए गए imatrix की ज़रूरत होती है। "मुझे सचमुच इसे VRAM में समाना ही है" के लिए तुरुप का पत्ता।
  • imatrix (importance matrix): मॉडल में एक कैलिब्रेशन टेक्स्ट चलाकर यह मापें कि कौन-से वेट्स मायने रखते हैं, फिर कम बिट-डेप्थ पर उन्हीं की पहले रक्षा करें। K-quants के लिए वैकल्पिक, I-quants के लिए प्रभावी रूप से ज़रूरी। imatrix से बने GGUF कम बिट्स पर बेहतर टिकते हैं।

4. 4 फ़ॉर्मैट की तुलना (GGUF / GPTQ / AWQ / EXL2)

यहाँ हर प्रमुख फ़ॉर्मैट का स्वभाव, GPU वाले भी शामिल।

GGUF

एकमात्र फ़ॉर्मैट जो CPU/Mac/मिश्रित पर चलता है। llama.cpp का मानक। K-quant/I-quant/imatrix के साथ लचीला। लोकल निजी उपयोग के लिए पहली पसंद।

GPTQ

GPU 4-bit मानक। कैलिब्रेशन के ज़रिए लेयर-दर-लेयर त्रुटि न्यूनतम करता है। vLLM/TGI पर तेज़। अब इसका उत्तराधिकारी GPTQModel है।

AWQ

activations देखकर "अहम वेट्स" की रक्षा करता है (activation-aware)। GPU, weight-only 4-bit। vLLM/TGI पर व्यापक उपयोग।

EXL2 / EXL3

बिट-चौड़ाई को भिन्न (fraction) के रूप में सेट करें (जैसे 4.5 bpw)। केवल ExLlama, GPU। EXL3 एक नई QTIP-आधारित शृंखला है, अभी परिपक्व हो रही।

💡 GPTQ बनाम AWQ (संक्षेप में): GPTQ "लेयर-दर-लेयर पुनर्निर्माण त्रुटि न्यूनतम करता है," जबकि AWQ "activation वितरण देखकर अहम ~1% वेट्स की रक्षा करता है।" कौन जीतेगा यह मॉडल, बिट-चौड़ाई और कार्यान्वयन पर निर्भर करता है, इसलिए कोई भी सार्वभौमिक रूप से बेहतर नहीं है। बस वही चुनें जिसे आपका इंजन सपोर्ट करता हो।

5. कौन-सी फ़ाइल / बिट-डेप्थ चुनें

फ़ॉर्मैट तय हो जाने के बाद अगली बात बिट-डेप्थ है। GGUF को उदाहरण मानकर, "संशय हो तो यही चुनें" के लिए एक व्यावहारिक सीढ़ी (अंक अनुमानित हैं और मॉडल तथा बिल्ड के अनुसार बदलते हैं)।

फ़ाइलभूमिकाकब चुनें
Q4_K_Mआम स्वीट स्पॉट (कई मॉडलों के लिए Ollama का डिफ़ॉल्ट)संशय हो तो। आम तौर पर सर्वश्रेष्ठ आकार/गुणवत्ता संतुलन
Q5_K_M / Q6_Kपूर्ण गुणवत्ता के करीबVRAM बचा हो और एक पायदान और ऊपर चाहिए
Q8_0लगभग बिना-हानि पर अनुशंसित नहींशायद ही ज़रूरत (नन्ही गुणवत्ता बढ़त के लिए कहीं ज़्यादा RAM/धीमा)
IQ2 / IQ3 (I-quant)बहुत कम बिट्स पर ठूँसनाकेवल तब जब बड़े मॉडल को VRAM में समाना ज़रूरी हो

अंगूठे के नियम के तौर पर, लोग अक्सर कहते हैं कि प्रति वेट लगभग 4.5–5 बिट्स (Q4_K–Q5_K) "स्वादिष्ट" पट्टी है (एक हेयुरिस्टिक)। Q6 से ऊपर गुणवत्ता की बढ़त धीमी पड़ जाती है, और Q8_0 या FP16 थोड़े-से अंतर के लिए मेमोरी और रफ़्तार में भारी क़ीमत माँगते हैं—यही व्यावहारिक आम राय है। शुरुआत Q4_K_M चलाकर करें, कम लगे तो Q5/Q6 तक बढ़ें, न समाए तो IQ पर उतरें, और चलते-चलते ट्यून करें। ज़रूरी VRAM का अनुमान लगाने के लिए देखें local LLM हार्डवेयर आवश्यकताएँ।

6. Hugging Face और Ollama पर फ़ाइलें ढूँढना

Hugging Face पर library=gguf से GGUF फ़िल्टर करें, या किसी quant री-पैकेजर के repo पर जाएँ। लिखते समय, bartowski और mradermacher सक्रिय रूप से GGUF (imatrix बिल्ड सहित) प्रकाशित करते हैं—पर री-पैकेजर की सक्रियता बदलती रहती है, इसलिए नवीनतम अपलोड तारीख जाँचें। (TheBloke के कभी-मानक repos अब भी मौजूद हैं, पर नए अपलोड काफ़ी हद तक रुक चुके हैं।) अपना खुद का कन्वर्ट करने के लिए, आधिकारिक gguf-my-repo Space काम आता है।

Ollama पर, टैग model:size-variant-quant का पालन करते हैं।

# कोई टैग नहीं = डिफ़ॉल्ट (कई मॉडलों के लिए Q4_K_M)
ollama pull llama3.1

# quant को स्पष्ट रूप से चुनें
ollama pull llama3.1:8b-instruct-q5_K_M
ollama pull qwen2.5-coder:7b-instruct-q8_0

# उपलब्ध टैग देखें ollama.com/library/<model>/tags

तो असली वर्कफ़्लो तीन चालों का है: इंजन तय करें → उसके फ़ॉर्मैट तक सिमटें → वह बिट-डेप्थ फ़ाइल चुनें जो आपके VRAM में समाए। इसमें महारत पा लें और 20-फ़ाइल की दीवार आपको परेशान करना छोड़ देती है। असल में किसी एक को चलाने के लिए, देखें local LLM कैसे चलाएँ और Ollama गाइड।

सारांश

क्वांटाइज़ेशन फ़ॉर्मैट चुनना दो चरणों का है। पहले ① आप इसे किस इंजन पर चलाएँगे—लोकल CPU/Mac → GGUF; रफ़्तार के लिए GPU सर्वर → GPTQ/AWQ; एक GPU पर बारीक बिट-चौड़ाई → EXL2; झटपट Transformers टेस्ट → bitsandbytes। शीर्ष नियम: फ़ॉर्मैट केवल उन्हीं इंजनों पर चलता है जो उसे सपोर्ट करते हैं।

फिर ② बिट-डेप्थ। GGUF का Q4_K_M मतलब "4-bit, K-quant, साइज़ M"—आम डिफ़ॉल्ट। संशय हो तो, Q4_K_M → (जगह हो तो) Q5/Q6 → (न समाए तो) IQ। ~4.5–5 bpw "स्वादिष्ट पट्टी" हेयुरिस्टिक पर टिकें और चलते-चलते ट्यून करें। imatrix बिल्ड कम बिट्स पर बेहतर टिकते हैं। संबंधित: क्वांटाइज़ेशन क्या है, local LLM कैसे चलाएँ, हार्डवेयर आवश्यकताएँ, सर्वश्रेष्ठ लोकल मॉडल, Ollama गाइड।

FAQ

Q. तो मुझे कौन-सी फ़ाइल चुननी चाहिए?
A. पहले तय करें "आप इसे किस इंजन पर चलाएँगे।" अपना PC या Mac (Ollama/LM Studio) → GGUF; एक GPU सर्वर (vLLM/TGI) → GPTQ या AWQ। फिर बिट-डेप्थ के लिए, संशय हो तो Q4_K_M (अच्छा आकार/गुणवत्ता संतुलन, और कई मॉडलों के लिए Ollama का डिफ़ॉल्ट)। VRAM बचा हो तो Q5_K_M/Q6_K; केवल तब जब बड़े मॉडल को समाना ज़रूरी हो, IQ2/IQ3 पर विचार करें।

Q. Q4_K_M का क्या मतलब है?
A. तीन हिस्से। Q4 = ~4-bit (बड़ा अंक = ज़्यादा गुणवत्ता, बड़ी फ़ाइल), K = K-quant (सुपर-ब्लॉक्स पर स्मार्ट क्वांटाइज़ेशन; साधारण या _0/_1 पुराने हैं), और M = साइज़ medium (S/M/L यह है कि कुछ अहम टेंसर्स को कितना ऊँची बिट्स में अपग्रेड किया जाता है)। असरदार बिट्स लेबल से ज़रा ऊपर चलती हैं (Q4_K ≈ 4.5 bpw)।

Q. GGUF और GPTQ/AWQ में क्या फ़र्क़ है?
A. उनके सपोर्ट किए गए रनटाइम (हार्डवेयर) से। GGUF एकमात्र "लोकल सब-कुछ" फ़ॉर्मैट है जो CPU, Mac, और आंशिक-GPU पर चलता है, llama.cpp/Ollama के लिए। GPTQ और AWQ GPU-पहले हैं और vLLM/TGI पर हाई थ्रूपुट के लिए उपयुक्त। ये तरीके में भी अलग हैं (GPTQ लेयर-दर-लेयर त्रुटि न्यूनतम करता है; AWQ activations के ज़रिए अहम वेट्स की रक्षा करता है), पर कोई भी सार्वभौमिक रूप से बेहतर नहीं है। बस वही चुनें जिसे आपका इंजन सपोर्ट करता हो।

Q. IQ (I-quant) सामान्य Q4 से कैसे अलग है?
A. यह उसी बिट-डेप्थ पर और भी छोटा हो सकता है (एक नई, codebook-आधारित विधि)। बदले में, इन्फ़रेंस ज़रा भारी होता है, और गुणवत्ता बनाए रखने के लिए इसे व्यावहारिक रूप से एक imatrix की ज़रूरत होती है। इसका उपयोग "बड़े मॉडल को VRAM में समाना ही है" के लिए तुरुप का पत्ता है। अगर सामान्य रूप से समा जाए, तो Q4_K_M जैसा K-quant काम करने में आसान है।

Q. क्या Q8_0 या FP16 ज़्यादा गुणवत्ता वाले नहीं? फिर "अनुशंसित नहीं" क्यों?
A. ये वाकई लगभग बिना-हानि हैं, पर ये Q5/Q6 पर केवल नन्ही गुणवत्ता बढ़त के लिए कहीं ज़्यादा मेमोरी खाते हैं और धीमे चलते हैं। यहाँ तक कि llama.cpp समुदाय भी सामान्य उपयोग के लिए इन्हें अनुशंसित नहीं करता। व्यवहार में, लगभग 4.5–5 bpw (Q4_K–Q5_K) "स्वादिष्ट" पट्टी है, और वहाँ से ज़रूरत अनुसार ऊपर-नीचे जाते हैं (अंक अनुमानित हैं और मॉडल/बिल्ड के अनुसार बदलते हैं)।