Ollama quantization: Q4, Q8 आणि fp16 मधील फरक
Ollama मॉडेलसाठी योग्य quantization कसे निवडावे? q4_K_M, q8_0 आणि fp16 मधील RAM वापर, अचूकतेतील फरक आणि तुमच्या हार्डवेअरसाठी सर्वोत्तम पर्याय कोणता हे सविस्तर जाणून घ्या.
Ollama quantization मुळे होणारे बदल
Ollama quantization मध्ये मॉडेलमधील प्रत्येक weight ज्या file मध्ये प्रशिक्षित केले गेले त्यापेक्षा कमी bits मध्ये साठवला जातो. q4_K_M ने संपणारा tag प्रत्येक weight साठी सुमारे four bits ठेवतो, तर fp16 sixteen bits ठेवतो. त्यामुळे download साधारण एक-तृतीयांश आकाराचा होतो आणि प्रत्येक token तयार करण्यासाठी मशीनला साधारण एक-तृतीयांश bytes वाचावे लागतात. Weights पूर्णपणे काढून टाकले जात नाहीत; त्यांना coarse grid वर round केले जाते. four bits असतानाही बहुतेक मॉडेल्स full precision प्रमाणेच जवळपास उत्तरे देतात.
हा संपूर्ण तडजोडीचा मुद्दा आहे: memory footprint खूप कमी होतो आणि प्रति सेकंद अधिक tokens तयार होतात; त्याची किंमत accuracy मध्ये होणारी छोटी घट आहे. विशिष्ट मॉडेलसाठी आणि विशिष्ट मशीनवर हे दोन्ही परिणाम कसे असतील, file download करण्यापूर्वी त्याचा अंदाज कसा घ्यायचा, हे पुढे पाहू. अन्यथा बसणार नाही अशी file download करण्यासाठी वीस मिनिटे खर्च होऊ शकतात.
Ollama अद्याप चालू नसेल, तर VPS वर Ollama install करणे यापासून सुरुवात करा. या पृष्ठावर ollama ls आधीपासून कार्यरत आहे असे गृहीत धरले आहे.
Ollama quantization tag जसे की q4_K_M कसे वाचावे
स्थानिक मॉडेल्स GGUF फाइल्स म्हणून येतात, जे llama.cpp द्वारे वेट्स (weights) डिस्कवर साठवण्यासाठी वापरले जाणारे फॉरमॅट आहे. Ollama हे llama.cpp वर आधारित आहे, त्यामुळे Ollama टॅग्समध्ये llama.cpp ची क्वांटायझेशन नावे जशीच्या तशी वापरली जातात.
संख्या म्हणजे लक्ष्यित रुंदी (target width). q4 चा अर्थ असा की बहुतेक वेट टेन्सर्स प्रत्येकी चार बिट्समध्ये पॅक केलेले आहेत. q8 म्हणजे आठ बिट्स. fp16 चे अजिबात क्वांटायझेशन केलेले नसते: हे मॉडेल सोळा-बिट फ्लोटिंग पॉइंटमध्ये असते, ज्या अचूकतेमध्ये बहुतेक मॉडेल्स प्रकाशित केली जातात.
K हे K-quant दर्शवते. वेट्सना लहान ब्लॉक्समध्ये गटबद्ध केले जाते आणि प्रत्येक ब्लॉक पॅक केलेल्या मूल्यांच्या शेजारी स्वतःचे स्केल साठवतो. ज्या ब्लॉकचे सर्व वेट्स 0.01 च्या जवळ असतात, त्याला सूक्ष्म (fine) स्केल मिळते. ज्या ब्लॉक मध्ये एक मोठा आउटलायर असतो, त्याला स्थूल (coarse) स्केल मिळते. हे प्रति-ब्लॉक स्केल्सच चार-बिट फाइलला वापरण्यायोग्य ठेवतात आणि याच कारणामुळे चार-बिट फाइल कधीही प्रति वेट अचूक चार बिट्सची नसते.
शेवटचे अक्षर हे मिश्रण (mixture) दर्शवते. S, M आणि L हे ठरवतात की किती टेन्सर्सना लक्ष्यित रुंदीपेक्षा जास्त प्रमोट करायचे. q4_K_M मध्ये, ज्या टेन्सर्सना राउंड केल्यामुळे सर्वात जास्त नुकसान होते, ते अधिक रुंद साठवले जातात, तर उर्वरित भाग चार बिट्सवरच राहतो. म्हणूनच q4_K_M हे जुन्या q4_0 पेक्षा जवळजवळ समान फाइल आकारात अधिक चांगले आउटपुट देते.
तुम्ही टाइप केलेल्या नावावरून अंदाज लावण्याऐवजी, डिस्कवर काय आहे हे Ollama ला विचारा:
ollama pull qwen3:8b-q4_K_M
ollama show qwen3:8b-q4_K_Mollama show हे architecture, parameters, quantization, context length आणि embedding length प्रिंट करते. quantization ओळ ही तुम्ही काही महिन्यांपूर्वी पुल केलेल्या आणि निवडल्याचे आता आठवत नसलेल्या मॉडेलसाठी खरी माहिती (ground truth) असते.
फाईलचा आकार ठरवणारे 'बिट्स पर वेट' (Bits per weight)
फाईलच्या आकाराचा कोणताही अंदाज एका संख्येपासून सुरू होतो: संपूर्ण फाईलमध्ये सरासरी किती बिट्स प्रति वेट (bits per weight) वापरले जातात. llama.cpp ने त्यांच्या quantize दस्तऐवजीकरणामध्ये Llama 3.1 8B साठी मोजलेली आकडेवारी दिली आहे, जी समान रचनेच्या कोणत्याही dense मॉडेलसाठी लागू पडते.
या तक्त्यामागील डेटा
[
{
"label": "F16",
"bits_per_weight": 16,
"file_gib": 14.96
},
{
"label": "Q8_0",
"bits_per_weight": 8.5,
"file_gib": 7.95
},
{
"label": "Q6_K",
"bits_per_weight": 6.56,
"file_gib": 6.14
},
{
"label": "Q5_K_M",
"bits_per_weight": 5.7,
"file_gib": 5.33
},
{
"label": "Q4_K_M",
"bits_per_weight": 4.89,
"file_gib": 4.58
},
{
"label": "Q3_K_M",
"bits_per_weight": 3.99,
"file_gib": 3.74
}
]त्या तक्त्यातील दुसरा स्तंभ आश्चर्यकारक आहे. Q4_K_M म्हणजे चार बिट्स प्रति वेट असे नाही. याचे मोजमाप 4.89 बिट्स इतके येते, कारण ब्लॉक स्केल्स आणि प्रमोट केलेले टेन्सर्स (promoted tensors) यासाठी प्रत्यक्ष जागा लागते. याच कारणामुळे Q8_0 चे मोजमाप आठ ऐवजी 8.5 बिट्स येते. मोजलेल्या संख्येचा वापर केल्यास, गणिताचे उत्तर प्रत्यक्ष फाईलच्या आकाराच्या काही टक्के फरकाने मिळते:
weight bytes = parameter count x bits per weight / 8
8.03e9 params x 4.89 bits / 8 = 4.91e9 bytes = 4.57 GiBही 4.58 GiB आकाराची Q4_K_M फाईल आहे, जी दोन संख्यांवरून काढली आहे. लोड झाल्यानंतर वेट्स (weights) जेवढी मेमरी व्यापतात, ती देखील साधारणपणे इतकीच असते. Ollama लोड करताना कोणतीही गोष्ट अनपॅक (unpack) करत नाही: क्वांटाइज्ड वेट्स मेमरीमध्ये त्याच पॅक केलेल्या स्वरूपात राहतात आणि प्रत्येक ब्लॉक वापरला जातो तेव्हा त्याचे रूपांतर केले जाते.
Ollama प्रत्येक model size साठी प्रत्यक्षात काय उपलब्ध करून देते
बहुतेक family साठी library q4_K_M, q8_0 आणि fp16 tag प्रकाशित करते. काही नवीन family हा pattern पाळत नाहीत. त्या library मध्ये cloud-only tag म्हणून दिसतात आणि कोणत्याही size साठी pull करण्यास काहीही उपलब्ध नसते. VPS वर GLM 5.2 चालवण्याचा प्रयत्न करताना तुम्हाला हीच अडचण येते. October 2026 पर्यंत Qwen3 चे हे size आहेत. ही माहिती model page वरील tag list मधून घेतली आहे. खालील प्रत्येक आकडा RAM मध्ये जाण्यापूर्वीचा disk आकार दर्शवतो. यापैकी दोन किंवा तीन model एकत्र घेतल्यास छोट्या VPS चा root volume भरू शकतो. त्यामुळे tag गोळा करण्यापूर्वी Ollama डाउनलोड केलेले model कुठे साठवते हे माहिती असणे उपयुक्त ठरते.
या तक्त्यामागील डेटा
[
{
"label": "Qwen3 4B",
"q4_K_M_gb": 2.6,
"q8_0_gb": 4.4,
"fp16_gb": 8.1
},
{
"label": "Qwen3 8B",
"q4_K_M_gb": 5.2,
"q8_0_gb": 8.9,
"fp16_gb": 16
},
{
"label": "Qwen3 14B",
"q4_K_M_gb": 9.3,
"q8_0_gb": 16,
"fp16_gb": 30
},
{
"label": "Qwen3 32B",
"q4_K_M_gb": 20,
"q8_0_gb": 35,
"fp16_gb": 66
}
]येथे default tag महत्त्वाचा आहे. ollama pull qwen3:8b आणि ollama pull qwen3:8b-q4_K_M अगदी समान 5.2 GB डाउनलोड करतात, कारण suffix नसलेला tag हा q4_K_M build असतो. Q4_K_M हा library अनिच्छेने देत असलेला तडजोडीचा पर्याय नाही. तो upstream ने निवडलेला default आहे. त्यामुळे स्वतः तपासलेले नसलेल्या कोणत्याही model साठी सुरुवातीला तोच वापरणे योग्य ठरते. VPS वर Qwen 3 चालवताना tag निवडण्यामागेही हाच विचार आहे.
हे प्रमाण प्रत्येक row साठी लागू होते. q4_K_M वरून q8_0 कडे गेल्यास आकार नेमका दुप्पट होत नाही; तो सुमारे सत्तर टक्क्यांनी वाढतो. याचे कारण embedding आणि output tensor चा आकार उर्वरित tensor प्रमाणे वाढत नाही. fp16 चा आकार q4_K_M पेक्षा साधारण तीनपट असतो. q4_K_M मधील 32B model च्या weights चा आकार 20 GB आहे. कोणतीही context window वापरायची असल्यास 16 GB मशीनमध्ये तो आधीच बसत नाही. कोणत्या मशीनवर कोणते model बसते याचे विस्तृत चित्र पाहण्यासाठी तुम्ही self-host करू शकणारे model पहा.
KV cache हा दुसरा, context वर अवलंबून असलेला खर्च आहे
Weights हा स्थिर खर्च आहे. KV cache (key आणि value cache) हा बदलणारा खर्च आहे. Context window मधील प्रत्येक token साठी प्रत्येक layer चे key आणि value vectors cache मध्ये ठेवले जातात. त्यामुळे तुम्ही अनुमती दिलेल्या window च्या प्रमाणात cache सरळ रेषेत वाढतो. Model load होताना पूर्ण window साठी cache allocate केला जातो. Conversation भरत जाईल तसा तो हळूहळू allocate होत नाही. म्हणून एकाच शब्दाच्या prompt साठीसुद्धा मोठ्या window मुळे memory खर्च होते.
KV bytes per token = 2 (key and value) x layers x kv_heads x head_dim x bytes_per_element
Qwen3 8B at f16: 2 x 36 x 8 x 128 x 2 = 147456 bytes = 144 KiB per tokenही model numbers model च्या configuration मधून येतात: 36 layers, 8 key/value heads आणि head dimension 128. ollama show मध्ये architecture आणि parameter count मिळतो. Hugging Face वरील model चे config.json उर्वरित माहिती देते. प्रत्येक token चा खर्च window size ने गुणल्यावर cache हा नगण्य rounding error राहत नाही.
या तक्त्यामागील डेटा
[
{
"label": "4k",
"kv_cache_gb": 0.6,
"floor_ram_gb": 5.8
},
{
"label": "8k",
"kv_cache_gb": 1.21,
"floor_ram_gb": 6.4
},
{
"label": "16k",
"kv_cache_gb": 2.42,
"floor_ram_gb": 7.6
},
{
"label": "32k",
"kv_cache_gb": 4.83,
"floor_ram_gb": 10
}
]4096 tokens वर, म्हणजे 24 GiB पेक्षा कमी VRAM असताना Ollama निवडत असलेल्या default window वर (CPU-only VPS सहित), weights व्यतिरिक्त cache 0.6 GB memory घेतो. Window 32k पर्यंत वाढवल्यास cache एकटाच 4.83 GB होतो. हे quantized weights इतक्याच memory च्या जवळपास आहे. त्यामुळे संपूर्ण model साठी किमान memory 10 GB होते. याला किमान मर्यादा म्हणण्याचे कारण म्हणजे compute buffers आणि operating system यासाठी त्यावर अतिरिक्त memory लागते. Model load झाल्यानंतर ollama ps मधील SIZE column मधून प्रत्यक्ष figure वाचा. 24 ते 48 GiB VRAM असलेल्या GPU वर default window 32k असतो. 48 GiB पासून तो 256k असतो. त्यामुळे मोठ्या card वर 4k figure गृहीत धरू नका.
Ollama service म्हणून चालवताना window server वर सेट केला जातो, प्रत्येक request साठी वेगळा नाही:
OLLAMA_CONTEXT_LENGTH=8192 ollama servesystemd install साठी त्याऐवजी तो drop-in मध्ये द्या:
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"sudo systemctl restart ollama ने restart करा. त्यानंतर ollama ps मधील CONTEXT column तपासा. यामुळे चालू model प्रत्यक्षात कोणत्या window सह load झाला आहे ते निश्चित करता येते. OLLAMA_KV_CACHE_TYPE cache स्वतः quantize करते: f16 हा default आहे, q8_0 मुळे f16 च्या तुलनेत सुमारे निम्मी memory वापरली जाते आणि q4_0 मुळे सुमारे एक चतुर्थांश memory वापरली जाते. हा global option आहे. त्यामुळे त्या server वरील प्रत्येक model वर तोच परिणाम होतो. Cache quantization फक्त Flash Attention enabled असताना लागू होते. Backend support करत असल्यास Ollama ते आपोआप enabled करते आणि OLLAMA_FLASH_ATTENTION=1 ते सक्तीने enabled करते. लहान box वर मोठे window वापरताना cache अर्धा केल्याने इतर कोणत्याही एका बदलापेक्षा जास्त memory मोकळी होते. हा saving लागू करण्यापूर्वी तपासायचा असल्यास, KV cache f16 वरून q8_0 मध्ये बदलणे या setting ची आणि model reload झाल्यानंतर ollama ps मध्ये दिसणाऱ्या घटची माहिती देते. num_ctx सेट करणे आणि त्याची किंमत या भागात window चे सविस्तर वर्णन आहे. Cache server साठी एकदाच नव्हे, तर प्रत्येक concurrent request slot साठी स्वतंत्रपणे आकारला जातो. त्यामुळे Ollama ला एकाच वेळी दोन prompts ची उत्तरे देऊ दिल्यास तुम्ही नुकताच budget केलेला figure दुप्पट होतो. याच गणितावर parallel slot count आणि queue limit निवडणे आधारित आहे.
8, 16 किंवा 32 GB VPS वर काय बसू शकते
मॉडेलचे वजन (weights), KV cache आणि ऑपरेटिंग सिस्टम व इतर चालू असलेल्या प्रक्रियांच्या गरजा यांचा विचार करणे आवश्यक आहे. लहान VPS वर 2 GB ची अतिरिक्त जागा (headroom) पुरेशी असते.
8 GB. q4_K_M मधील 4B मॉडेल 2.6 GB जागा घेते आणि मोठ्या window साठी पुरेशी जागा शिल्लक ठेवते. q4_K_M मधील 8B मॉडेल डीफॉल्ट 4k window सह बसते, पण त्यात फारशी मोकळी जागा उरत नाही. येथे 32k window सह 8B मॉडेल चालवण्याचा विचार करू नका, कारण 10 GB ची किमान मर्यादा आधीच मर्यादेच्या बाहेर जाते.
16 GB. 16k किंवा 32k window सह q4_K_M मधील 8B मॉडेल आरामात चालते. q4_K_M मधील 14B मॉडेलचे वजन 9.3 GB आहे आणि ते एका मर्यादित window सह बसते. q8_0 मधील 8B मॉडेल 8.9 GB चे आहे, त्यामुळे ते देखील बसते. या दोन्ही मॉडेल्सची तुमच्या स्वतःच्या प्रॉम्प्ट्सवर तुलना करणे, हा या विषयावर घालवलेला सर्वात उपयुक्त वेळ ठरेल.
32 GB. q8_0 मधील 14B (16 GB) आणि q4_K_M मधील 32B (20 GB) ही दोन्ही मॉडेल्स लोड होतात. मोठ्या window सह 32B बिल्ड वापरताना ते क्षमतेच्या मर्यादेपर्यंत पोहोचेल, त्यामुळे गृहीत धरण्यापेक्षा ollama ps वर लक्ष ठेवा.
क्वांटायझेशनमध्ये प्रथम काय खराब होते
क्वांटायझेशनमुळे होणारी त्रुटी मॉडेलच्या सर्व कार्यांवर समान रीतीने पसरत नाही. भाषेचा ओघ (fluency) सर्वात जास्त काळ टिकून राहतो, आणि म्हणूनच हे नुकसान ओळखणे कठीण असते: खराब क्वांटायझेशन केलेले मॉडेल देखील स्पष्ट वाक्ये लिहू शकते. अचूकता (precision) सर्वात आधी कमी होते. जसे की, व्हर्जन नंबर, API सिग्नेचर किंवा तारखेची तंतोतंत आठवण. तर्कशास्त्राच्या लांब साखळ्या, जिथे दुसऱ्या पायरीवरील एक छोटी चूक आठव्या पायरीवर चुकीचे उत्तर देते. तसेच, कठोर आउटपुट फॉरमॅट्स, जिथे एक चुकीचा कंस (bracket) टूल कॉल अयशस्वी करतो.
शेवटचा मुद्दा ही एक व्यावहारिक चाचणी आहे. जेव्हा मॉडेलला JSON फॉरमॅटमध्ये उत्तर द्यावे लागते जे तुमचा कोड पार्स करतो, तेव्हा क्वांटायझेशनचे नुकसान हे अस्पष्ट लेखनाऐवजी पार्सिंग एरर म्हणून समोर येते, त्यामुळे तुम्हाला ते त्याच दिवशी समजते. कोडिंग एजंट ही या चाचणीची सर्वात कठीण आवृत्ती आहे, कारण ते मॉडेलला एकामागून एक टूल कॉल करायला भाग पाडते. त्यामुळे तुमच्या Ollama सर्व्हरवर एजंट वापरून पाहणे तुम्हाला काही तासांतच अति-आक्रमक क्वांटायझेशनचे परिणाम दाखवून देईल.
चार बिट्सच्या खाली कार्यक्षमता वेगाने कमी होते. q3 आणि दोन बिट प्रकार अशा लोकांसाठी आहेत जे मोठ्या मॉडेलला लहान हार्डवेअरवर बसवण्याचा प्रयत्न करत आहेत, आणि जेव्हा मॉडेल न चालवण्यापेक्षा हा पर्याय निवडणे भाग असते, तेव्हा ते उपयुक्त ठरतात. मात्र, हे डिफॉल्ट म्हणून वापरणे चुकीचे आहे. q4_K_M आणि q8_0 मधील फरक इतका कमी आहे की केवळ प्रसिद्ध केलेली perplexity टेबल तुमच्या वर्कलोडसाठी निर्णय घेऊ शकत नाही, त्यामुळे त्या आधारावर निर्णय घेऊ नका. तुमच्या स्वतःच्या तीस प्रॉम्प्ट्सवर दोन्ही चालवून पहा आणि आउटपुट तपासा.
q8_0 किंवा fp16 कधी वापरावे
जेव्हा मेमरी मुबलक उपलब्ध असते आणि कामात लहान चुकाही चालत नाहीत, तेव्हा q8_0 वापरा: जसे की स्ट्रक्चर्ड एक्सट्रॅक्शन (structured extraction), टूल कॉलिंग किंवा कोड जो कंपाईल होणे आवश्यक आहे. येथे तुम्ही मॉडेलची बुद्धिमत्ता वाढवत नसून, त्रुटींपासून संरक्षण मिळवत आहात.
fp16 केवळ दोन कारणांसाठी वापरा. एकतर तुम्ही स्वतः मॉडेलचे क्वांटायझेशन करत आहात आणि तुम्हाला सोर्स फाईलची गरज आहे, किंवा तुम्ही बेसलाईन मोजत आहात जेणेकरून तुमच्या फोर-बिट बिल्डमध्ये किती अचूकता कमी झाली हे तुम्हाला समजेल. fp16 वरून सर्व्हिंग केल्यास q4_K_M च्या तुलनेत तीनपट मेमरी खर्च होते, ज्यातील फरक बहुतेक लोकांना ओळखता येत नाही. तसेच, केवळ CPU असलेल्या मशीनवर यामुळे तुमचा टोकन रेट एक-तृतीयांश होतो.
निश्चित मेमरी बजेट असताना एक महत्त्वाचा नियम: q4_K_M वरील मोठे मॉडेल हे सहसा q8_0 वरील लहान मॉडेलपेक्षा सरस ठरते. 9.3 GB चे 14B वेट्स आणि 8.9 GB चे 8B वेट्स यासाठी जवळपास सारखीच RAM (random access memory) लागते, परंतु मोठे मॉडेल अधिक माहितीपूर्ण असते. हे कोणाच्या सांगण्यावर विश्वास ठेवण्यापेक्षा स्वतःच्या प्रॉम्प्ट्सवर तपासून पहा.
केवळ CPU वर आधारित इन्फरन्स मेमरी बँडविड्थमुळे मर्यादित असतो
बहुतेक VPS प्लॅन्समध्ये GPU नसतो, त्यामुळे मॉडेल होस्ट CPU च्या सिस्टिम मेमरीमध्ये चालते. अशा वेळी जनरेशनचा वेग हा गणिताच्या क्षमतेवर नाही, तर मेमरी बँडविड्थवर अवलंबून असतो, कारण एक टोकन तयार करण्यासाठी प्रत्येक वेट (weight) एकदा वाचावे लागते. यामुळे एक अशी मर्यादा येते ज्याचा तुम्ही किती कोअर्स (cores) विकत घेतले आहेत याच्याशी काहीही संबंध नसतो.
tokens per second ceiling = memory bandwidth / bytes read per token
50 GB/s / 5.2 GB = 9.6 tokens/s qwen3 8B q4_K_M
50 GB/s / 8.9 GB = 5.6 tokens/s qwen3 8B q8_0
50 GB/s / 16 GB = 3.1 tokens/s qwen3 8B fp1650 GB/s हा ड्युअल चॅनेल DDR4-3200 होस्टसाठीचा अंदाजे सैद्धांतिक आकडा आहे. तुमचा वाटा त्यापेक्षा कमी असतो, कारण VPS वर मशीनमधील इतर सर्व भाडेकरूंसोबत (tenants) ती बस शेअर केली जाते. त्यामुळे या आकड्यांकडे अशी मर्यादा म्हणून पहा जिथे कोणीही पोहोचू शकत नाही. यातील महत्त्वाचा भाग म्हणजे आकारमान: CPU वर, प्रति वेट बिट्स निम्म्यावर आणल्यास टोकन रेट साधारणपणे दुप्पट होतो. GPU नसलेल्या बॉक्सवर क्वांटायझेशन (quantization) हे वेग वाढवण्याचे सर्वात प्रभावी साधन आहे. उरलेला वेग तुमच्यासाठी स्वीकारार्ह आहे का, हे मॉडेलवर अवलंबून असते आणि VPS वर Nemotron 3.5 Lightning हे विशिष्ट बिल्ड, टॅग आणि RAM च्या आकडेवारीसह त्याचे विश्लेषण करते. प्रतीक्षेचा दुसरा भाग म्हणजे मॉडेल किती मजकूर लिहिण्याचे ठरवते, कारण 10 टोकन्स प्रति सेकंद या वेगाने 600 टोकन्सचे उत्तर मिळण्यासाठी पूर्ण एक मिनिट लागतो. त्यामुळे num_predict वापरून उत्तरावर मर्यादा घालणे हे अचूकता (precision) कमी करण्यापेक्षा जास्त वेळ वाचवू शकते.
प्रॉम्प्ट प्रोसेसिंगची वागणूक वेगळी असते. मोठा प्रॉम्प्ट वाचणे हे बँडविड्थपेक्षा कॉम्प्युटवर (compute) अवलंबून असते, त्यामुळे तिथे अतिरिक्त कोअर्स मदत करतात, तर जनरेशनच्या वेगावर त्यांचा काहीही परिणाम होत नाही. जो बॉक्स 4k प्रॉम्प्ट वेगाने स्वीकारतो आणि त्यानंतर हळू जनरेट करतो, तो सामान्यपणे काम करत आहे असे समजावे.
कोणत्याही गणितावर आंधळेपणाने विश्वास ठेवू नका. तुमच्या स्वतःच्या बॉक्सवर प्रति सेकंद टोकन्स मोजा आणि प्रत्येक क्वांटायझेशनसाठी समान प्रॉम्प्ट वापरून मिळालेल्या आकड्यांनाच अंतिम माना.
स्वतः model quantize करणे
तुम्ही एखादे model fine-tune केले असेल आणि त्यासाठी library tag उपलब्ध नसेल, तेव्हा ही पद्धत महत्त्वाची ठरते. शेवटी कोणता format हवा आहे यावर मार्ग अवलंबून असतो, कारण Ollama आता या पानावर मोजलेले GGUF K-quants तयार करत नाही.
q4_K_M सारख्या K-quant साठी, Ollama कडे file देण्यापूर्वी quantize करा. Import करताना Ollama GGUF models quantize करत नाही आणि GGUF source वर --quantize नाकारते. Unquantized GGUF ला llama.cpp मधील llama-quantize वापरून quantize करा आणि तयार झालेली file import करा. या import पद्धतीत एक स्वतंत्र अडचण आहे: chat template mismatch मुळे model निरर्थक उत्तर देऊ शकतो. Ollama मध्ये GGUF file import करणे याची सविस्तर पद्धत देते. Import केलेली file तुम्हाला अपेक्षित build आहे का, हे पडताळण्यासाठी ollama show मधील quantization line वापरा.
Ollama चे स्वतःचे --quantize फक्त safetensors imports वर कार्य करते. Unquantized safetensors weights असलेल्या directory कडे Modelfile निर्देशित करा:
FROM /path/to/safetensors/directoryत्यानंतर build करा:
ollama create --quantize int4 mymodelOllama v0.40.2 नुसार (2026-10-11 रोजी तपासलेले), --quantize मध्ये int4, int8, nvfp4, mxfp4 आणि mxfp8 स्वीकारले जातात. तसेच q4 आणि q8, तसेच fp4 आणि fp8, हे अनुक्रमे int4 आणि int8 यांचे aliases म्हणून घेतले जातात. q4_K_M, q4_K_S, q8_0, q6_K आणि q5_K_M यांसारखी GGUF names unsupported quantize type error सह नाकारली जातात. हे types वरील tables मधील GGUF K-quants नाहीत. त्यामुळे या पानावरील bits per weight आणि file size चे आकडे त्यांच्यासाठी अंदाज म्हणून वापरू नका.
जेव्हा काही बिघडते तेव्हा काय दिसते
तुम्ही GPU ची अपेक्षा केली असताना सर्व काही CPU वर चालते. PROCESSOR कॉलम वाचा:
ollama psहे 100% GPU, 100% CPU, किंवा 48%/52% CPU/GPU सारखे विभाजन दर्शवते. विभाजनाचा अर्थ असा आहे की weights आणि KV cache हे VRAM (ग्राफिक्स कार्डवरील मेमरी) मध्ये मावले नाहीत, त्यामुळे मॉडेलचा काही भाग सिस्टम मेमरीमध्ये ठेवला गेला आहे. प्रत्येक टोकन धीम्या भागाची वाट पाहत असल्याने वेग थेट CPU च्या वेगाच्या जवळ येतो. कॉन्टेक्स्ट विंडो कमी करा, कॅशे क्वांटाइज करा किंवा लहान बिल्ड वापरा. अधिक कोअर्स जोडल्याने काहीही उपयोग होणार नाही.
लोड होत असताना मॉडेल बंद (kill) केले जाते. कर्नल आणि सर्व्हिस लॉग तपासा:
sudo dmesg -T | grep -i "out of memory"
sudo journalctl -u ollama -n 50Out of memory: Killed process असलेली ओळ दर्शवते की weights, KV cache आणि बफरची एकूण मेमरी बॉक्समधील मेमरीपेक्षा जास्त झाली आहे. ज्या VPS वर swap कॉन्फिगर केलेले नाही, तिथे ती ओळ दिसण्यापूर्वी संपूर्ण मशीन काही सेकंदांसाठी स्तब्ध होऊ शकते.
तुम्ही काहीही बदलले नसताना उत्तरे खराब झाली आहेत. एकाच मॉडेलचे दोन बिल्ड्स ollama ls मध्ये वेगवेगळ्या टॅग्स अंतर्गत असू शकतात आणि जो स्क्रिप्ट unsuffixed नाव पुल करते, ती लायब्ररी सध्या ज्याला पॉइंट करत आहे त्याचे अनुसरण करेल. तुमच्या क्लायंटने विनंती केलेल्या नेमक्या टॅगवर ollama show चालवा आणि quantization ओळ वाचा, तुमच्या कॉन्फिगरेशन फाईलमधील नावावर विश्वास ठेवण्याऐवजी हे करा.
FAQ
कोणती Ollama quantization डाउनलोड करावी?
q4_K_M पासून सुरुवात करा. बहुतेक मॉडेलसाठी Ollama library हे default tag म्हणून प्रकाशित करते, त्यामुळे ollama pull qwen3:8b आणि ollama pull qwen3:8b-q4_K_M समान file डाउनलोड करतात. Memory उपलब्ध असेल आणि task मध्ये लहान चुका सहन होत नसतील, जसे tool calling किंवा structured JSON output, तेव्हाच q8_0 वापरा. Memory budget निश्चित असेल, तर q4_K_M वरील मोठे मॉडेल q8_0 वरील लहान मॉडेलपेक्षा सहसा चांगली कामगिरी करते; त्यामुळे precision साठी RAM वापरण्यापूर्वी या pairing ची चाचणी करा.
q4_K_M म्हणजे प्रत्येक weight साठी खरोखर four bits का?
नाही. Llama 3.1 8B वर मोजल्यास ते प्रत्येक weight साठी 4.89 bits आहे, कारण weights च्या प्रत्येक block मध्ये स्वतःचा scale साठवला जातो आणि सर्वाधिक sensitive tensors ला अधिक रुंद type मध्ये promote केले जाते. त्याच कारणामुळे Q8_0 चे मोजमाप eight ऐवजी 8.5 bits येते. अंदाजासाठी measured figure वापरा: parameter count गुणिले bits per weight, भागिले eight, यामुळे file size bytes मध्ये मिळतो.
केवळ CPU असलेल्या VPS वर 8B मॉडेलसाठी किती RAM आवश्यक आहे?
Weights, KV cache आणि headroom यांची बेरीज करा. q4_K_M मधील Qwen3 8B साठी weights चे प्रमाण 5.2 GB आहे. Default 4096 token window वर cache मध्ये आणखी 0.6 GB लागतात. त्यामुळे compute buffers आणि operating system धरून घेण्यापूर्वी किमान प्रमाण जवळपास 5.8 GB असते. 32k window वर cache साठीच 4.83 GB लागतात. Short window साठी 8 GB आणि long window हवी असल्यास 16 GB यांचे नियोजन करा.
मशीनमध्ये GPU असताना माझे मॉडेल 100% CPU वर का चालते?
ollama ps चालवा आणि PROCESSOR column वाचा. 100% CPU किंवा 48%/52% CPU/GPU सारखे split याचा अर्थ weights आणि KV cache VRAM मध्ये बसले नाहीत. त्यामुळे Ollama ने मॉडेलचा काही भाग किंवा संपूर्ण मॉडेल system memory मध्ये ठेवले. नेहमीचे कारण म्हणजे context window card च्या क्षमतेपेक्षा मोठी असणे, कारण मॉडेल load होताना संपूर्ण window साठी cache allocate केला जातो. OLLAMA_CONTEXT_LENGTH वापरून window कमी करा, cache निम्मा करण्यासाठी OLLAMA_KV_CACHE_TYPE=q8_0 ला value द्या, किंवा smaller quantization डाउनलोड करा.