GGUF फ़ॉर्मेट: लोकल LLM इंफरेंस के लिए एक संपूर्ण गाइड

GGUF क्या है?

GGUF, जिसका पूरा नाम GGML Unified Format है, एक बाइनरी फ़ाइल फ़ॉर्मेट है जो मॉडल वेट्स, टोकनाइज़र डेटा, आर्किटेक्चर मेटाडेटा, और क्वांटाइज़ेशन जानकारी को एक एकल, पोर्टेबल फ़ाइल में पैक करता है ताकि GGML-आधारित रनटाइम्स, खासकर llama.cpp, के साथ इंफरेंस किया जा सके।

GGUF एक LLM डिप्लॉयमेंट समस्या को हल करता है। कई मॉडल फ़ॉर्मेट्स उपयोगकर्ताओं से कई फाइलें साथ रखने की मांग करते हैं, जिनमें मॉडल वेट्स, टोकनाइज़र फाइलें, कॉन्फ़िगरेशन फाइलें, और आर्किटेक्चर-विशिष्ट लोडिंग कोड शामिल होते हैं। GGUF इसे सरल बनाता है क्योंकि मॉडल फ़ाइल को काफी हद तक सेल्फ-डिस्क्राइबिंग बना देता है।

एक GGUF फ़ाइल में आम तौर पर ये होते हैं:

• मॉडल टेन्सर्स
• क्वांटाइज़्ड या अनक्वांटाइज़्ड वेट्स
• टोकनाइज़र शब्दावली
• टोकनाइज़र कॉन्फ़िगरेशन
• मॉडल आर्किटेक्चर मेटाडेटा
• कॉन्टेक्स्ट लंबाई सेटिंग्स
• एंबेडिंग डायमेंशंस
• अटेंशन हेड काउंट
• RoPE कॉन्फ़िगरेशन
• टेन्सर नाम, आकार, और डेटा प्रकार

मुख्य विचार यह है कि फ़ाइल स्वयं का विवरण देती है। रनटाइम मेटाडेटा को देखकर आर्किटेक्चर समझ सकता है, टोकनाइज़र लोड कर सकता है, और टेन्सर्स को मैप कर सकता है, बिना अलग config.json या टोकनाइज़र फ़ोल्डर पर निर्भर हुए।

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

GGUF की चार परिभाषित विशेषताएं हैं:

1. सिंगल-फ़ाइल डिप्लॉयमेंट
2. कुशल लोडिंग के लिए मेमोरी मैपिंग सपोर्ट
3. एक्सटेंसिबल टाइप्ड की-वैल्यू मेटाडेटा
4. कई क्वांटाइज़ेशन प्रकारों का समर्थन, आक्रामक लो-बिट फ़ॉर्मेट्स से लेकर फुल प्रिसीजन तक

GGUF को 2023 में llama.cpp और GGML इकोसिस्टम के हिस्से के रूप में पेश किया गया था। अब यह Hugging Face पर क्वांटाइज़्ड लोकल LLMs वितरित करने का प्रमुख फ़ॉर्मेट है।

GGUF बनाम GGML

GGML (Georgi Gerganov Machine Learning) फ़ॉर्मेट GGUF का पूर्ववर्ती था। यह महत्वपूर्ण था क्योंकि इसने शुरुआती लोकल इंफरेंस को संभव बनाने में मदद की। हालांकि, जब इकोसिस्टम मूल LLaMA मॉडलों से आगे बढ़ा, तो इसमें व्यावहारिक सीमाएँ सामने आईं।

आम GGML समस्याओं में शामिल थे:

• कम लचीला मेटाडेटा हैंडलिंग
• आर्किटेक्चर-विशिष्ट लोडिंग मान्यताओं पर अधिक निर्भरता
• टोकनाइज़र और कॉन्फ़िगरेशन हैंडलिंग जो कम सेल्फ-कंटेन्ड थी
• नई मॉडल फैमिलीज़ के आने पर एक्स्टेंसिबिलिटी में कठिनाई

GGUF ने एक अधिक संरचित फ़ॉर्मेट के साथ उन सीमाओं को संबोधित किया। इसने टाइप्ड मेटाडेटा, बेहतर टोकनाइज़र एंबेडिंग, और एक स्पष्ट फ़ाइल लेआउट पेश किया। इससे llama.cpp और संबंधित टूल्स के लिए नए आर्किटेक्चर का समर्थन करना आसान हुआ, बिना लोडिंग पाइपलाइन को बार-बार फिर से डिज़ाइन किए।

उपयोगकर्ताओं के लिए, महत्वपूर्ण अंतर सरल है: GGUF आधुनिक फ़ॉर्मेट है। अगर आप आज मॉडल डाउनलोड कर रहे हैं, तो आपको लगभग हमेशा पुराने GGML फाइलों की बजाय GGUF चुनना चाहिए।

GGUF बनाम GPTQ और AWQ

फ़ाइल फ़ॉर्मेट्स की खोज में, आप GGUF, GPTQ (Generative Post-Training Quantization), और AWQ (Activation-Aware Weight Quantization) पर ज़रूर पहुँचे होंगे। इन्हें अक्सर साथ में चर्चा की जाती है क्योंकि तीनों का उपयोग LLM इंफरेंस को अधिक कुशल बनाने के लिए होता है। हालांकि, ये एक जैसे वर्ग नहीं हैं।

GGUF मुख्य रूप से एक फ़ाइल फ़ॉर्मेट और डिप्लॉयमेंट कंटेनर है। यह कई क्वांटाइज़ेशन प्रकारों का समर्थन करता है और llama.cpp-शैली के लोकल इंफरेंस से क़रीबी रूप से जुड़ा है।

GPTQ और AWQ क्वांटाइज़ेशन विधियाँ और इकोसिस्टम हैं, जिनका उपयोग आमतौर पर GPU-ऑप्टिमाइज़्ड इंफरेंस के लिए होता है, खासकर NVIDIA हार्डवेयर पर, जैसे फ्रेमवर्क्स Transformers, ExLlama, AutoGPTQ, और vLLM-संगत वर्कफ़्लोज़ के जरिए।

यदि आपका लक्ष्य लैपटॉप, डेस्कटॉप, Apple Silicon, और मिश्रित हार्डवेयर में अधिकतम संगतता है, तो GGUF आमतौर पर सुरक्षित विकल्प है।

यदि आपका लक्ष्य समर्पित NVIDIA इंफरेंस सर्वरों पर अधिकतम थ्रूपुट है, तो GPTQ, AWQ, FP8, या अन्य GPU-ऑप्टिमाइज़्ड सर्विंग फ़ॉर्मेट अधिक उपयुक्त हो सकते हैं।

GGUF क्यों उपयोग करें?

GGUF लोकप्रिय हुआ क्योंकि यह व्यावहारिक डिप्लॉयमेंट समस्याओं को हल करता है। मैंने भी पाया है कि लोकल डिप्लॉयमेंट में सेटअप की जटिलताओं से बचने के लिए यह बहुत सुविधाजनक है।

लोकल LLMs चलाने में पहले बिखरे हुए टूल्स, बड़े अनकंप्रेस्ड वेट्स, असंगत मॉडल फ़ॉर्मेट्स, और जटिल सेटअप चरण शामिल होते थे। GGUF अब उस वर्कफ़्लो के बड़े हिस्से को मानकीकृत करने में मदद कर सकता है।

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

मॉडल्स को लोकल चलाएँ

GGUF आपको अपने स्वयं के मशीन पर LLMs चलाने देता है। इसका मतलब है:

• प्रति-टोकन API लागत नहीं
• होस्टेड इंफरेंस प्रदाता पर निर्भरता नहीं
• प्रॉम्प्ट्स को थर्ड-पार्टी API को भेजने की जरूरत नहीं
• मॉडल डाउनलोड होने के बाद ऑफ़लाइन इंफरेंस संभव

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

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

लोकल स्तर पर मॉडल चलाने के व्यावहारिक अभ्यास के लिए, हमारे ट्यूटोरियल देखें — SGLang के साथ Mistral Medium 3.5 की सर्विंग, DeepSeek V4 Flash को लोकल चलाना, पुराने लैपटॉप पर कुशल Bonsai 1-bit मॉडल चलाना, और MiniMax M2 को लोकल कोडिंग असिस्टेंट के रूप में चलाना।

हार्डवेयर लचीलापन

GGUF उपयोगी है क्योंकि यह कई हार्डवेयर कॉन्फ़िगरेशनों में काम करता है।

रनटाइम और बैकएंड पर निर्भर करते हुए, GGUF मॉडल्स चल सकते हैं:

• केवल CPU वाली मशीनों पर
• CUDA के जरिए NVIDIA GPUs पर
• Metal के जरिए Apple Silicon पर
• HIP या Vulkan के जरिए AMD GPUs पर
• SYCL या Vulkan के जरिए Intel GPUs पर
• कुछ ARM और मोबाइल वातावरणों पर

यह लचीलापन ही है जिसकी वजह से llama.cpp प्रभावशाली बना। इसे केवल हाई-एंड सर्वर GPUs के लिए नहीं बनाया गया था। इसे व्यापक हार्डवेयर पर लोकल इंफरेंस संभव बनाने के लिए डिज़ाइन किया गया था।

उदाहरण के लिए, Mac उपयोगकर्ता Metal एक्सेलेरेशन पर निर्भर हो सकता है, जबकि Linux डेस्कटॉप उपयोगकर्ता CUDA या Vulkan का उपयोग कर सकता है। केवल CPU वाला उपयोगकर्ता भी छोटे क्वांटाइज़्ड मॉडलों को चला सकता है, हालांकि जेनरेशन स्पीड धीमी होगी।

विस्तृत इकोसिस्टम सपोर्ट

GGUF कई लोकल इंफरेंस टूल्स द्वारा समर्थित है। उदाहरण शामिल हैं:

• कमांड-लाइन और सर्वर इंफरेंस के लिए llama.cpp
• CLI-प्रथम मॉडल प्रबंधन और API एक्सेस के लिए Ollama
• LM Studio एक डेस्कटॉप GUI के रूप में
• निजता-केंद्रित लोकल चैट के लिए GPT4All
• लोकल रोलप्ले और टेक्स्ट-जनरेशन वर्कफ़्लोज़ के लिए KoboldCpp
• लोकल AI इंटरफ़ेस के लिए Jan और Open WebUI

यह इसलिए मायने रखता है क्योंकि उपयोगकर्ता एक इंटरफ़ेस में बंधे नहीं होते। वही सामान्य मॉडल फ़ॉर्मेट अलग-अलग वर्कफ़्लोज़ में उपयोग किया जा सकता है।

एक डेवलपर llama.cpp के साथ मॉडल का बेंचमार्क कर सकता है, LM Studio में उससे चैट कर सकता है, Ollama के जरिए उसे सर्व कर सकता है, और Open WebUI के जरिए ब्राउज़र UI से जोड़ सकता है।

Hugging Face पर वितरण

Hugging Face, GGUF मॉडलों के लिए एक प्रमुख डिस्ट्रीब्यूशन हब बन गया है।

स्रोत: Hugging Face

कई लोकप्रिय ओपन-वेट मॉडलों को रिलीज़ के तुरंत बाद समुदाय द्वारा अपलोड किए गए GGUF वेरिएंट मिल जाते हैं। इन रिपॉज़िटरीज़ में अक्सर कई क्वांटाइज़ेशन विकल्प होते हैं, ताकि उपयोगकर्ता अपने हार्डवेयर के अनुरूप मॉडल चुन सकें।

आम अपलोड वेरिएंट में शामिल हैं:

• Q4_K_M
• Q5_K_M
• Q6_K
• Q8_0
• IQ4_XS
• IQ3_M
• IQ2_XXS

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

आकार-गुणवत्ता पर सूक्ष्म नियंत्रण

GGUF उपयोगकर्ताओं को आकार-गुणवत्ता ट्रेडऑफ़ पर बारीक नियंत्रण देता है। आप चुन सकते हैं:

• कम-मेमोरी मशीनों के लिए छोटे क्वांटाइज़ेशन
• संतुलित दैनिक उपयोग के लिए मिड-रेंज क्वांटाइज़ेशन
• कोडिंग, रीज़निंग, या स्ट्रक्चर्ड आउटपुट के लिए उच्च-बिट क्वांटाइज़ेशन
• जब मेमोरी बाधा न हो, तब फुल या लगभग फुल प्रिसीजन

यह लचीलापन इस फ़ॉर्मेट का सबसे बड़ा लाभ है। एक तय डिप्लॉयमेंट लक्ष्य के बजाय, GGUF एक ही मॉडल फैमिली को कई हार्डवेयर टियर पर अनुकूलित करने देता है।

GGUF कैसे काम करता है?

एक GGUF फ़ाइल तीन बड़े हिस्सों में संगठित होती है:

1. हेडर
2. मेटाडेटा और टेन्सर जानकारी
3. टेन्सर डेटा

सटीक संरचना GGUF स्पेसिफ़िकेशन द्वारा परिभाषित है। महत्वपूर्ण बात यह है कि रॉ टेन्सर डेटा से पहले मेटाडेटा और टेन्सर जानकारी आती है, जिससे रनटाइम समझ पाता है कि वह क्या लोड करने वाला है।

हेडर

हेडर फ़ाइल को GGUF के रूप में पहचानता है और रनटाइम को बताता है कि बाकी फ़ाइल को कैसे पार्स करना है। इसमें शामिल हैं:

• GGUF के लिए मैजिक नंबर
• फ़ॉर्मेट वर्ज़न
• टेन्सर काउंट
• मेटाडेटा की-वैल्यू काउंट

आधुनिक GGUF फाइलें आमतौर पर GGUF वर्ज़न 3 का उपयोग करती हैं।

इंफरेंस इंजन सबसे पहले मैजिक नंबर की जाँच करते हैं। यदि फ़ाइल अपेक्षित GGUF पहचानकर्ता से शुरू नहीं होती, तो रनटाइम टेन्सर्स पार्स करने या मेमोरी आवंटित करने की कोशिश से पहले ही उसे अस्वीकार कर सकता है।

यह सरल लेकिन महत्वपूर्ण सुरक्षा और विश्वसनीयता कदम है। यह रनटाइम को किसी असंबंधित बाइनरी फ़ाइल को गलती से मॉडल समझने से रोकता है।

मेटाडेटा की-वैल्यू पेयर्स

GGUF मेटाडेटा एक टाइप्ड की-वैल्यू स्टोर है। यह मेटाडेटा वर्णन कर सकता है:

• सामान्य मॉडल जानकारी
• आर्किटेक्चर फैमिली
• कॉन्टेक्स्ट लंबाई
• एंबेडिंग साइज
• लेयर्स की संख्या
• अटेंशन हेड्स की संख्या
• RoPE पैरामीटर्स
• टोकनाइज़र शब्दावली
• स्पेशल टोकन्स
• क्वांटाइज़ेशन जानकारी

कीज़ आमतौर पर नेमस्पेस्ड होती हैं। उदाहरण:

• general.architecture
• general.alignment
• llama.context_length
• tokenizer.ggml.tokens

नेमस्पेसिंग महत्वपूर्ण है क्योंकि यह GGUF को कई आर्किटेक्चर का समर्थन करने देता है, बिना पूरे फ़ाइल फ़ॉर्मेट को बदले। LLaMA-फैमिली मॉडल llama.* कीज़ का उपयोग कर सकते हैं, जबकि अन्य मॉडल फैमिलीज़ अपनी आर्किटेक्चर-विशिष्ट मेटाडेटा कीज़ का उपयोग कर सकती हैं।

यही कारण है कि GGUF मूल LLaMA परिवार से परे Qwen, Mistral, Gemma, DeepSeek, Phi, और अन्य जैसे आर्किटेक्चर तक अच्छी तरह अनुकूलित हुआ।

टेन्सर जानकारी और टेन्सर डेटा

मेटाडेटा के बाद, फ़ाइल टेन्सर जानकारी और टेन्सर डेटा स्टोर करती है।

टेन्सर जानकारी में वर्णन होता है:

• टेन्सर का नाम
• आकार
• डेटा प्रकार
• टेन्सर डेटा सेक्शन में ऑफ़सेट

टेन्सर डेटा सेक्शन में वास्तविक मॉडल वेट्स होते हैं। ये वेट्स फुल प्रिसीजन में या GGUF द्वारा समर्थित किसी क्वांटाइज़्ड टेन्सर प्रकार में स्टोर हो सकते हैं।

GGUF मेटाडेटा में परिभाषित एलाइनमेंट वैल्यू का उपयोग करता है, आम तौर पर general.alignment। कई GGUF फाइलें 32-बाइट एलाइनमेंट का उपयोग करती हैं, लेकिन सही विवरण यह है कि एलाइनमेंट हार्डकोड होने के बजाय मेटाडेटा द्वारा नियंत्रित होता है।

एलाइनमेंट इसलिए मायने रखता है क्योंकि यह रनटाइम्स को टेन्सर ब्लॉक्स को कुशलता से एक्सेस करने देता है।

मेमोरी मैपिंग

GGUF का एक व्यावहारिक लाभ मेमोरी मैपिंग है, जिसे अक्सर mmap कहा जाता है।

मेमोरी मैपिंग के साथ, ऑपरेटिंग सिस्टम पूरे फ़ाइल को RAM में कॉपी करने के लिए रनटाइम को मजबूर करने के बजाय मॉडल फ़ाइल को वर्चुअल मेमोरी में मैप कर सकता है।

यह मॉडल स्टार्टअप को, खासकर SSDs पर, बहुत तेज़ महसूस करा सकता है। यह ऑपरेटिंग सिस्टम को जरूरत के अनुसार मॉडल डेटा को पेज इन और आउट करने भी देता है।

हालांकि, मेमोरी मैपिंग कोई जादू नहीं है। मॉडल को अच्छी तरह चलने के लिए पर्याप्त वास्तविक मेमोरी बैंडविड्थ और उपलब्ध RAM या VRAM की अब भी जरूरत होती है। यदि आपका सिस्टम लगातार डिस्क से पेजिंग कर रहा है, तो इंफरेंस धीमा हो सकता है।

mmap के बारे में बेहतर सोच यह है:

• यह लोडिंग दक्षता में सुधार करता है
• यह अनावश्यक कॉपीिंग को कम करता है
• यह OS को पेजिंग मैनेज करने देता है
• यह इंफरेंस की मेमोरी आवश्यकताओं को समाप्त नहीं करता

GGUF क्वांटाइज़ेशन प्रकारों को समझना

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

हर वेट को 16-बिट फ्लोटिंग पॉइंट वैल्यू के रूप में स्टोर करने के बजाय, एक क्वांटाइज़्ड मॉडल अनुमानित मानों को कम बिट्स का उपयोग करके स्टोर करता है। इससे डिस्क आकार, RAM और VRAM उपयोग, और मेमोरी बैंडविड्थ का दबाव घटता है।

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

GGUF क्वांटाइज़ेशन नेमिंग

GGUF क्वांटाइज़ेशन नाम आमतौर पर इस पैटर्न का पालन करते हैं:

• Q का मतलब quantized
• संख्या लगभग प्रति-वेट बिट्स का संकेत देती है
• K k-quant फैमिली को संदर्भित करता है
• S, M, और L आमतौर पर small, medium, और large वेरिएंट दर्शाते हैं

उदाहरण:

• Q4_K_M
• Q5_K_M
• Q6_K
• Q8_0

नाम एक उपयोगी मार्गदर्शक है, लेकिन यह हमेशा कुल फ़ाइल आकार का सटीक बयान नहीं होता। वास्तविक फ़ाइल आकार टेन्सर मिक्स, आर्किटेक्चर, मेटाडेटा, टोकनाइज़र आकार, और क्या कुछ टेन्सर्स उच्च प्रिसीजन में रहते हैं, इस पर निर्भर करता है।

आम GGUF क्वांटाइज़ेशन प्रकार

ये संख्या 7B-श्रेणी के डेंस मॉडलों के लिए अनुमान हैं। नए आर्किटेक्चर, mixture-of-experts मॉडल, बड़े टोकनाइज़र, और अलग टेन्सर लेआउट वास्तविक फ़ाइल आकार बदल सकते हैं।

व्यवहार में, Q4_K_M एक लोकप्रिय डिफ़ॉल्ट बन गया क्योंकि यह आकार और गुणवत्ता के बीच अच्छा संतुलन देता है। कई उपयोगकर्ता इसे जनरल चैट, समरीकरण, रीराइटिंग, और एक्सप्लोरेटरी लोकल AI काम के लिए पर्याप्त पाते हैं।

Q5_K_M और Q6_K अक्सर अधिक मांग वाले वर्कलोड्स—जैसे कोडिंग या मल्टी-स्टेप निर्देश पालन—के लिए बेहतर विकल्प होते हैं

कारण सरल है: ये कार्य छोटी गुणवत्ता गिरावट के प्रति अधिक संवेदनशील होते हैं।

K-quants बनाम I-quants

K-quants व्यापक रूप से उपयोग की जाने वाली क्वांटाइज़ेशन फैमिली है, जिसके पीछे Q4_K_M, Q5_K_M, और Q6_K जैसे फ़ॉर्मेट्स आते हैं।

ये ग्रुप्ड क्वांटाइज़ेशन स्कीम्स का उपयोग करते हैं, जिनमें स्केलिंग जानकारी होती है जो मेमोरी आवश्यकताओं को घटाते हुए मॉडल व्यवहार को संरक्षित रखने में मदद करती है। ये लोकप्रिय हैं क्योंकि ये भरोसेमंद, व्यापक रूप से समर्थित, और समुदाय के GGUF रिलीज़ में आसानी से मिल जाते हैं।

I-quants, जिन्हें अक्सर IQ फ़ॉर्मेट्स के रूप में लिखा जाता है, नए क्वांटाइज़ेशन प्रकार हैं, जैसे:

• IQ4_XS
• IQ3_M
• IQ2_XXS
• IQ1_S

I-quants बहुत छोटे आकारों पर बेहतर गुणवत्ता हासिल करने के लिए डिज़ाइन किए गए हैं। ये importance-aware quantization और non-linear quantization codebooks जैसी तकनीकों का उपयोग कर सकते हैं। कुछ वर्कफ़्लोज़ एक importance मैट्रिक्स, जिसे अक्सर imatrix कहा जाता है, का उपयोग करते हैं ताकि क्वांटाइज़ेशन के दौरान अधिक महत्वपूर्ण वेट्स को संरक्षित रखा जा सके।

ट्रेडऑफ़ जटिलता है। I-quants बहुत कम बिटरेट्स पर भी उत्कृष्ट आकार-गुणवत्ता परिणाम दे सकते हैं, लेकिन इनके लिए अधिक सावधान क्वांटाइज़ेशन वर्कफ़्लोज़ और रनटाइम सपोर्ट की जरूरत पड़ सकती है।

अधिकांश शुरुआती उपयोगकर्ताओं के लिए, K-quants सबसे आसान शुरुआती बिंदु बने रहते हैं।

अपने हार्डवेयर के लिए क्वांटाइज़ेशन स्तर चुनना

नीचे की तालिका व्यावहारिक शुरुआती बिंदु देती है। इन्हें कड़े नियम नहीं, बल्कि thumb rules समझें। कॉन्टेक्स्ट लंबाई, ऑपरेटिंग सिस्टम ओवरहेड, GPU ऑफ़लोडिंग, KV कैश आकार, और विशिष्ट मॉडल आर्किटेक्चर—ये सभी मेमोरी आवश्यकताएँ बदल सकते हैं।

सामान्य thumb rules:

• अधिकांश लोकल इंफरेंस के लिए Q4_K_M को सुरक्षित डिफ़ॉल्ट के रूप में उपयोग करें।
• जब गुणवत्ता हर गीगाबाइट बचत से अधिक मायने रखती है, तो Q5_K_M का उपयोग करें।
• जब मेमोरी उपलब्ध हो और आपको बेहतर विश्वसनीयता चाहिए, तो Q6_K या Q8_0 का उपयोग करें।
• गंभीर काम के लिए Q2_K से बचें, जब तक कि आप अत्यधिक मेमोरी-सीमित परिदृश्यों का परीक्षण न कर रहे हों।
• खासतौर पर लंबे कॉन्टेक्स्ट विंडोज़ का उपयोग करते समय KV कैश के लिए अतिरिक्त मेमोरी छोड़ें।

KV कैश को नज़रअंदाज़ करना आसान है। एक मॉडल कम कॉन्टेक्स्ट लंबाई पर RAM में फिट हो सकता है, लेकिन बहुत लंबी कॉन्टेक्स्ट लंबाई पर असफल हो सकता है या धीमा पड़ सकता है, क्योंकि कैश अनुक्रम लंबाई के साथ बढ़ता है।

GGUF इकोसिस्टम

GGUF को अपनाना, जितना फ़ॉर्मेट के कारण है, उतना ही टूलिंग के कारण भी है।

कोई फ़ॉर्मेट तभी उपयोगी बनता है जब उपयोगकर्ता आसानी से मॉडल डाउनलोड, रन, निरीक्षण, कन्वर्ट, और सर्व कर सकें। GGUF को कमांड-लाइन टूल्स, डेस्कटॉप ऐप्स, APIs, और होस्टेड मॉडल रिपॉज़िटरीज में मज़बूत इकोसिस्टम का लाभ मिलता है।

1. llama.cpp

llama.cpp मूल और सबसे महत्वपूर्ण GGUF रनटाइम है। यह Georgi Gerganov द्वारा बनाया गया एक हल्का C/C++ इंफरेंस इंजन है और GGML समुदाय द्वारा मेंटेन किया जाता है। इसका मुख्य लक्ष्य न्यूनतम सेटअप के साथ कई हार्डवेयर प्लेटफ़ॉर्म पर कुशल LLM इंफरेंस सक्षम करना है।

आधुनिक llama.cpp कई बैकएंड्स को सपोर्ट करता है, जिनमें शामिल हैं:

• CPU
• NVIDIA GPUs के लिए CUDA
• Apple डिवाइसों के लिए Metal
• Vulkan
• ROCm के जरिए AMD GPUs के लिए HIP
• Intel GPUs के लिए SYCL
• चयनित वातावरणों में OpenCL
• प्लेटफ़ॉर्म सपोर्ट पर निर्भर अन्य विशेष बैकएंड्स, जैसे CANN, OpenVINO, और WebGPU

यह कन्वर्ज़न, क्वांटाइज़ेशन, सर्विंग, बेंचमार्किंग, और कमांड-लाइन इंफरेंस के लिए टूल्स भी शामिल करता है। आम टूल्स में शामिल हैं:

• convert_hf_to_gguf.py
• llama-quantize
• llama-cli
• llama-server
• llama-bench

बेसिक CPU CMake बिल्ड बनाने के कमांड ये हैं:

cmake -B build
cmake --build build --config Release

कुछ कॉन्फ़िगरेशनों के लिए, उन दो कमांड्स में से पहले में कुछ फ़्लैग्स जोड़ने पड़ते हैं:

• macOS पर Apple Metal को डिसेबल करें (डिफ़ॉल्ट रूप से enabled): -DGGML_METAL=OFF
• Vulkan बिल्ड: -DGGML_VULKAN=1
• NVIDIA GPUs के लिए CUDA बिल्ड: -DGGML_CUDA=ON

ध्यान दें कि मौजूदा बिल्ड्स GGML_* CMake विकल्पों का उपयोग करते हैं, जैसे GGML_CUDA, GGML_VULKAN, और GGML_HIP।

2. Ollama

Ollama लोकल मॉडल्स चलाने के सबसे आसान तरीकों में से एक है। यह प्रदान करता है:

• एक सरल CLI
• मॉडल पुलिंग और मैनेजमेंट
• एक लोकल REST API
• आधिकारिक Python और JavaScript लाइब्रेरीज़
• कई लोकल AI फ्रंटएंड्स के साथ इंटीग्रेशन

Ollama आपके लिए मॉडल्स को स्टोर और मैनेज करता है, इसलिए उपयोगकर्ता आमतौर पर सीधे .gguf फाइलों के साथ इंटरैक्ट नहीं करते। हालांकि, Ollama llama.cpp-कम्पैटिबल लोकल इंफरेंस के इर्द-गिर्द बना है और Modelfile वर्कफ़्लो के जरिए GGUF फाइलें इम्पोर्ट भी कर सकता है।

Ollama एक लोकल API यहाँ एक्सपोज़ करता है:

http://localhost:11434/api

दो आमतौर पर इस्तेमाल होने वाले एंडपॉइंट्स हैं:

• /api/generate प्रॉम्प्ट कम्प्लीशन के लिए
• /api/chat चैट-शैली संदेशों के लिए

शुरुआत करने वालों के लिए, Ollama अक्सर शून्य से लोकल इंफरेंस तक का सबसे तेज़ रास्ता है।

3. LM Studio

स्रोत: LM Studio

LM Studio एक डेस्कटॉप एप्लीकेशन है जो लोकल मॉडलों को खोजने, डाउनलोड करने, और उनसे चैट करने के लिए है। यह उन उपयोगकर्ताओं के लिए उपयोगी है जो कमांड-लाइन टूल्स की बजाय ग्राफ़िकल इंटरफ़ेस पसंद करते हैं।

4. GPT4All

स्रोत: GPT4All

GPT4All एक और क्रॉस-प्लेटफ़ॉर्म लोकल AI एप्लिकेशन है, जो निजी, लोकल चैटबॉट वर्कफ़्लोज़ पर केंद्रित है। यह GGUF मॉडलों को सपोर्ट करता है और लोकल इंफरेंस के लिए शुरुआती-मित्र वातावरण प्रदान करता है।

ये टूल्स GGUF को गैर-विशेषज्ञों के लिए सुलभ बनाते हैं। उपयोगकर्ताओं को एक लोकल मॉडल आज़माने के लिए CMake, टेन्सर लेआउट्स, या क्वांटाइज़ेशन इंटरनल्स समझने की जरूरत नहीं होती।

GGUF मॉडल्स के साथ कैसे शुरुआत करें

शुरुआत करने के दो व्यावहारिक तरीके हैं:

1. सबसे सरल अनुभव के लिए Ollama का उपयोग करें।
2. अधिक नियंत्रण के लिए सीधे llama.cpp का उपयोग करें।

Ollama के साथ मॉडल चलाना

सबसे सरल वर्कफ़्लो है मॉडल डाउनलोड करना और एक इंटरैक्टिव चैट सत्र शुरू करना:

ollama pull llama3.3
ollama run llama3.3

REST API का उपयोग करते हुए Python से मॉडल कॉल करने के लिए:

import requests

payload = {
    "model": "llama3.3",
    "prompt": "Give me three practical use cases for GGUF.",
    "stream": False
}

response = requests.post(
    "http://localhost:11434/api/generate",
    json=payload
)

print(response.json()["response"])

चैट-शैली एप्लिकेशनों के लिए, /api/chat उपयोग करें:

import requests

payload = {
    "model": "llama3.3",
    "messages": [
        {"role": "user", "content": "What is GGUF used for?"}
    ],
    "stream": False
}

response = requests.post(
    "http://localhost:11434/api/chat",
    json=payload
)

print(response.json()["message"]["content"])

सरल स्क्रिप्ट्स के लिए stream: false फ़ील्ड महत्वपूर्ण है। इसके बिना, Ollama एक अंतिम JSON रिस्पॉन्स के बजाय JSON ऑब्जेक्ट्स की स्ट्रीम लौटाता है।

आप Ollama की आधिकारिक Python लाइब्रेरी का भी उपयोग कर सकते हैं:

from ollama import chat

response = chat(
    model="llama3.3",
    messages=[
        {"role": "user", "content": "Explain GGUF quantization simply."}
    ]
)

print(response.message.content)

llama.cpp के साथ GGUF फ़ाइल चलाना

यदि आपके पास पहले से .gguf फ़ाइल है, तो प्रोजेक्ट बिल्ड करने के बाद आप उसे सीधे llama.cpp से चला सकते हैं।

उदाहरण:

./build/bin/llama-cli \
  -m models/model.Q4_K_M.gguf \
  -p "Explain the difference between GGUF and GPTQ." \
  -n 256

यदि आपके पास GPU सपोर्ट सक्षम है, तो आप लेयर्स को GPU पर ऑफ़लोड कर सकते हैं:

./build/bin/llama-cli \
  -m models/model.Q4_K_M.gguf \
  -p "Summarize GGUF in five bullet points." \
  -n 256 \
  -ngl 99

-ngl फ़्लैग GPU पर ऑफ़लोड की जाने वाली लेयर्स की संख्या नियंत्रित करता है। 99 जैसा उच्च मान अक्सर जितना संभव हो उतना ऑफ़लोड करने के लिए उपयोग किया जाता है, बशर्ते मॉडल VRAM में फिट हो।

API सर्विंग के लिए, llama-server उपयोग करें:

./build/bin/llama-server \
  -m models/model.Q4_K_M.gguf \
  -ngl 99 \
  --host 127.0.0.1 \
  --port 8080

यह आपको एप्लिकेशनों में llama.cpp को इंटीग्रेट करने के लिए एक लोकल सर्वर इंटरफ़ेस देता है।

Hugging Face मॉडल को GGUF में कन्वर्ट करना

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

हालाँकि, मैनुअल कन्वर्ज़न तब उपयोगी होता है जब:

• आपने अपना मॉडल फाइन-ट्यून किया हो
• अभी GGUF संस्करण उपलब्ध न हो
• आप स्वयं क्वांटाइज़ेशन प्रक्रिया को नियंत्रित करना चाहते हों
• आपको किसी विशेष क्वांटाइज़ेशन प्रकार की आवश्यकता हो

एक सामान्य वर्कफ़्लो यह है:

1. Hugging Face से मॉडल डाउनलोड करें।
2. उसे GGUF में कन्वर्ट करें।
3. GGUF फ़ाइल को क्वांटाइज़ करें।

उदाहरण:

huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir mistral-7b

फिर GGUF में कन्वर्ट करें:

python convert_hf_to_gguf.py mistral-7b \
  --outfile mistral-f16.gguf \
  --outtype f16

फिर क्वांटाइज़ करें:

./build/bin/llama-quantize \
  mistral-f16.gguf \
  mistral-q4_k_m.gguf \
  Q4_K_M

मौजूदा llama.cpp वर्कफ़्लोज़ में, convert_hf_to_gguf.py और llama-quantize संबंधित टूल्स हैं। पुराने ट्यूटोरियल्स अप्रचलित कन्वर्ज़न स्क्रिप्ट्स या पुराने बाइनरी नामों का उल्लेख कर सकते हैं।

GGUF फ़ॉर्मेट के फायदे और सीमाएँ

GGUF, व्यावहारिक लोकल इंफरेंस के लिए ऑप्टिमाइज़्ड है। यह हर मॉडल फ़ॉर्मेट या सर्विंग स्टैक के लिए सार्वभौमिक प्रतिस्थापन नहीं है।

CPU-प्रथम, Apple Silicon, मिश्रित हार्डवेयर, और गोपनीयता-केंद्रित इंफरेंस के लिए, GGUF अक्सर एक उत्कृष्ट विकल्प है।

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

अंतिम विचार

GGUF, रनटाइम को आवश्यक हर चीज़ (वेट्स, टोकनाइज़र, मेटाडेटा, क्वांटाइज़ेशन जानकारी) एक पोर्टेबल फ़ाइल में पैक करके लोकल LLM इंफरेंस को व्यावहारिक बनाता है। इसकी असली ताकत इसके इकोसिस्टम में है: llama.cpp, Ollama, LM Studio, और Hugging Face—इन सबने इसे लोकल AI डिप्लॉयमेंट का डिफ़ॉल्ट फ़ॉर्मेट बना दिया है।

अधिकांश उपयोगकर्ताओं के लिए रास्ता सरल है: Ollama इंस्टॉल करें, मॉडल पुल करें, और चलाएँ। Q4_K_M एक ठोस डिफ़ॉल्ट है; बेहतर रीज़निंग या कोडिंग आउटपुट की जरूरत हो और मेमोरी उपलब्ध हो, तो Q5_K_M या Q6_K पर बढ़ें।

यदि आप LLM डिप्लॉयमेंट, मॉडल ऑप्टिमाइज़ेशन, और लोकल इंफरेंस वर्कफ़्लोज़ में गहराई तक जाना चाहते हैं, तो Associate AI Engineer for Data Scientists या Associate AI Engineer for Developers करियर ट्रैक देखें।