Ollama quantization: q4, q8 మరియు fp16 మధ్య తేడాలు
Ollama మోడల్స్ కోసం q4_K_M, q8_0 మరియు fp16 క్వాంటైజేషన్ ల మధ్య వ్యత్యాసాలను తెలుసుకోండి. RAM వినియోగం, వేగం మరియు మోడల్ నాణ్యతపై వీటి ప్రభావం గురించి పూర్తి విశ్లేషణ ఇక్కడ ఉంది.
Ollama quantization వల్ల మారేవి
Ollama quantizationలో model లోని ప్రతి weight ను అది train చేసిన file లో ఉన్న bit count కంటే తక్కువ bit count తో store చేస్తారు. q4_K_M తో ముగిసే tag ప్రతి weight కు సుమారు నాలుగు bits ఉంచుతుంది. fp16 పదహారు bits ఉంచుతుంది. అందువల్ల download పరిమాణం సుమారు మూడో వంతుకు తగ్గుతుంది. ప్రతి token ను రూపొందించేటప్పుడు machine చదవాల్సిన bytes కూడా సుమారు మూడో వంతు మాత్రమే ఉంటాయి. Weights ను తొలగించరు. వాటిని coarse grid పైకి round చేస్తారు. నాలుగు bits వద్ద కూడా ఎక్కువ models full precisionలో ఇచ్చిన సమాధానాలకు దగ్గరగా సమాధానాలు ఇస్తాయి.
ఇదే మొత్తం trade-off: memory footprint చాలా తగ్గుతుంది, secondsకు వచ్చే tokens సంఖ్య పెరుగుతుంది. దీనికి బదులుగా accuracy కొద్దిగా తగ్గుతుంది. నిర్దిష్ట modelను నిర్దిష్ట boxపై అమలు చేయడానికి ముందు ఈ రెండు ప్రభావాలను ఎలా అంచనా వేయాలో తరువాత వివరిస్తాం. సరిపోని fileను download చేయడానికి ఇరవై నిమిషాలు వెచ్చించకుండా ముందుగానే దీనిని తెలుసుకోవచ్చు.
Ollama ఇంకా నడుస్తూ లేకపోతే, ముందుగా VPSపై Ollamaను install చేయడం చూడండి. ఈ పేజీలో ollama ls ఇప్పటికే పనిచేస్తోందని భావిస్తున్నాం.
Ollama quantization tag ను q4_K_M వంటి రూపంలో ఎలా చదవాలి
Local models ను llama.cpp disk పై weights నిల్వ చేయడానికి ఉపయోగించే format అయిన GGUF files గా విడుదల చేస్తారు. Ollama, llama.cpp పై నిర్మించబడింది. అందువల్ల Ollama tags, llama.cpp quantization పేర్లను ఎలాంటి మార్పు లేకుండా కలిగి ఉంటాయి.
సంఖ్య target width ను సూచిస్తుంది. q4 అంటే ఎక్కువ weight tensors ఒక్కొక్కటి four bits వద్ద pack చేయబడతాయని అర్థం. q8 అంటే eight. fp16 అసలు quantize చేయబడదు. అది sixteen bit floating point లోని model; చాలా models ప్రచురించబడే precision ఇదే.
K K-quant ను సూచిస్తుంది. Weights ను చిన్న blocks గా సమూహపరుస్తారు. ప్రతి block తన scale ను packed values పక్కనే నిల్వ చేస్తుంది. ఒక block లోని weights అన్నీ 0.01 కు దగ్గరగా ఉంటే fine scale ఉపయోగిస్తుంది. ఒక block లో ఒక పెద్ద outlier ఉంటే coarse scale ఉపయోగిస్తుంది. ప్రతి block కు ఉండే ఈ scales వల్ల four bit file ఉపయోగించగలిగే స్థితిలో ఉంటుంది. అదే కారణంగా ప్రతి weight కు file ఖచ్చితంగా four bits ఉండదు.
చివరి అక్షరం mixture ను సూచిస్తుంది. S, M మరియు L target width కంటే ఎంతమంది tensors ను ఎక్కువ width కు పెంచాలో నిర్ణయిస్తాయి. q4_K_M లో rounding చేసినప్పుడు ఎక్కువ నష్టం కలిగించే tensors ను ఎక్కువ width లో నిల్వ చేస్తారు. మిగిలిన ఎక్కువ tensors four bits వద్ద ఉంటాయి. అందుకే దాదాపు అదే file size వద్ద పాత q4_0 కంటే q4_K_M మెరుగైన output ఇస్తుంది.
మీరు టైప్ చేసిన పేరు ఆధారంగా ఊహించకుండా, disk పై ఉన్నదేమిటో Ollama ను అడగండి:
ollama pull qwen3:8b-q4_K_M
ollama show qwen3:8b-q4_K_Mollama show, architecture, parameters, quantization, context length మరియు embedding length ను print చేస్తుంది. quantization line, నెలల క్రితం pull చేసి, ఎంచుకున్నది ఏదో ఇప్పుడు గుర్తులేని model కు వాస్తవ ఆధారం.
Bits per weight ఆధారంగానే file size నిర్ణయించబడుతుంది
ప్రతి size estimate ఒక సంఖ్యతో ప్రారంభమవుతుంది: మొత్తం file అంతటా సగటుగా format ప్రతి weight కోసం ఉపయోగించే bits సంఖ్య. llama.cpp తన quantize documentation లో Llama 3.1 8B కోసం కొలిచిన figures ను ప్రచురిస్తుంది. ఇవి సమాన ఆకృతిలో ఉన్న ఏ dense modelకైనా బాగా వర్తిస్తాయి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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
}
]ఆ table లో ఆశ్చర్యం కలిగించే విషయం రెండవ column. Q4_K_M ప్రతి weight కు four bits కాదు. ఇది 4.89 bits గా కొలవబడుతుంది. ఎందుకంటే block scales మరియు ఎక్కువ width కు పెంచిన tensors కూడా నిజమైన space ను వినియోగిస్తాయి. అదే కారణంతో Q8_0 eight bits కు బదులుగా 8.5 bits గా కొలవబడుతుంది. కొలిచిన సంఖ్యను ఉపయోగిస్తే, ఈ arithmetic నిజమైన file size కు కొన్ని శాతం లోపలికి వస్తుంది:
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 file. Load చేసిన తర్వాత weights ఆక్రమించే memory కూడా దాదాపు ఇదే. Load సమయంలో Ollama ఏదీ unpack చేయదు. Quantized weights memory లో అదే packed form లో ఉంటాయి. ప్రతి block ఉపయోగించే సమయంలో దానిని convert చేస్తుంది.
ప్రతి model size కోసం Ollama వాస్తవంగా అందించేది
చాలా familyల కోసం library ఒక q4_K_M, ఒక q8_0 మరియు ఒక fp16 tagను ప్రచురిస్తుంది. కొన్ని కొత్త familyలు ఈ పద్ధతికి మినహాయింపుగా ఉంటాయి. అవి libraryలో cloud only tagలుగా కనిపిస్తాయి. ఏ widthకైనా pull చేయడానికి వాటిలో ఏదీ ఉండదు. VPSలో GLM 5.2ను నడపడానికి ప్రయత్నించినప్పుడు ఎదురయ్యే పరిమితి ఇదే. ఇవి October 2026 నాటికి ఉన్న Qwen3 sizes. ఈ వివరాలను model pageలోని tag list నుంచి తీసుకున్నాం. క్రింద ఉన్న ప్రతి సంఖ్య ముందుగా disk పరిమాణాన్ని సూచిస్తుంది, RAM పరిమాణాన్ని కాదు. వీటిలో రెండు లేదా మూడు కలిపితే చిన్న VPS root volume నిండిపోతుంది. అందువల్ల tagలను సేకరించడం ప్రారంభించే ముందు Ollama డౌన్లోడ్ చేసిన modelsను ఎక్కడ నిల్వ చేస్తుందో తెలుసుకోవడం ఉపయోగకరం.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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ను download చేస్తుంది. కారణం, suffix లేని tag q4_K_M buildనే సూచిస్తుంది. Q4_K_M అనేది library ఇష్టంలేక అందించే రాజీ కాదు. upstream ఎంచుకున్న default ఇదే. కాబట్టి మీరు స్వయంగా పరీక్షించని ఏ modelకైనా మొదట దీన్నే ఎంచుకోవడం సమంజసం. VPSలో Qwen 3ను నడపడంలోని tag ఎంపికలకు కూడా ఇదే కారణం.
ఈ నిష్పత్తులు ప్రతి rowలోనూ వర్తిస్తాయి. q4_K_M నుంచి q8_0కి మారితే పరిమాణం సరిగ్గా రెండింతలు కాకుండా సుమారు 70 శాతం పెరుగుతుంది. దీనికి కారణం embedding మరియు output tensors, మిగతా భాగాల మాదిరిగా ఒకే నిష్పత్తిలో పెరగకపోవడం. fp16 పరిమాణం q4_K_M కంటే సుమారు మూడు రెట్లు ఉంటుంది. q4_K_Mలోని 32B model weights పరిమాణం 20 GB. ఏ context windowకైనా స్థలం ఉంచాలంటే 16 GB machineలో ఇది ఇప్పటికే సరిపోదు. ఏ machineలో ఏ models సరిపోతాయో విస్తృతంగా చూడటానికి మీరు self-host చేయగల models చూడండి.
KV cache రెండవ, context ఆధారిత ఖర్చు
Weights స్థిరమైన ఖర్చు. KV cache (key మరియు value cache) మారే ఖర్చు. Context window లోని ప్రతి token ప్రతి layer కోసం తన key మరియు value vectors ను నిల్వ ఉంచుతుంది. అందువల్ల మీరు అనుమతించే window పరిమాణానికి అనుపాతంగా cache పెరుగుతుంది. Model load అయినప్పుడు మొత్తం window కోసం cache కేటాయించబడుతుంది. Conversation పెరుగుతున్నకొద్దీ మాత్రమే ఇది కేటాయించబడదు. అందుకే ఒక పదం ఉన్న prompt అయినా long 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 సంఖ్యలు model స్వంత configuration నుంచి వస్తాయి: 36 layers, 8 key/value heads, మరియు head dimension 128. ollama show ద్వారా architecture మరియు parameter count తెలుసుకోవచ్చు. Model యొక్క config.json లో Hugging Face పై మిగిలిన వివరాలు ఉంటాయి. ప్రతి 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 కూడా ఇందులో ఉంటుంది, cache weightsపై అదనంగా 0.6 GB జోడిస్తుంది. Windowను 32kకు పెంచితే cache ఒక్కటే 4.83 GBకు చేరుతుంది. ఇది quantized weights వినియోగించే memoryకు దాదాపు సమానం. అప్పుడు మొత్తం modelకు కనీస memory 10 GB అవుతుంది. దీనిని కనీస పరిమితి అని పిలవడానికి కారణం compute buffers మరియు operating system memory దీనికి అదనంగా అవసరం కావడం. Model load అయిన తర్వాత SIZE యొక్క ollama ps column నుంచి వాస్తవ విలువను చూడండి. 24 నుంచి 48 GiB VRAM ఉన్న GPUలో default window 32k. 48 GiB నుంచి అది 256k. అందువల్ల పెద్ద cardలో 4k విలువనే ఆధారంగా భావించవద్దు.
మీరు 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 చేయండి. తరువాత running model వాస్తవంగా ఏ windowతో load అయిందో నిర్ధారించడానికి ollama psలోని CONTEXT columnను పరిశీలించండి. OLLAMA_KV_CACHE_TYPE cacheను కూడా quantize చేస్తుంది: f16 default. q8_0, f16 వినియోగించే memoryలో సుమారు సగం మాత్రమే ఉపయోగిస్తుంది. q4_0 సుమారు నాలుగో వంతు ఉపయోగిస్తుంది. ఇది global option. అందువల్ల ఆ serverలోని ప్రతి modelకు ఇదే విధానం వర్తిస్తుంది. Flash Attention enabled ఉన్నప్పుడే cache quantization అమలవుతుంది. Backend మద్దతు ఉన్నచోట Ollama దీన్ని స్వయంచాలకంగా enable చేస్తుంది. OLLAMA_FLASH_ATTENTION=1 దీన్ని బలవంతంగా enable చేస్తుంది. చిన్న systemలో long window ఉన్నప్పుడు cacheను సగానికి తగ్గించడం, మరే ఒక్క మార్పుకన్నా ఎక్కువ memoryని విడుదల చేస్తుంది. ఆ settingను నమ్మకంగా ఉపయోగించే ముందు దాని memory savingను చూడాలంటే KV cacheను f16 నుంచి q8_0కు మార్చడం అనే విభాగం, setting మరియు model reload అయిన తర్వాత ollama psలో అది చేసే తగ్గింపును వివరిస్తుంది. num_ctxను సెట్ చేయడం మరియు దాని ఖర్చు window గురించి పూర్తిగా వివరిస్తుంది. Cache serverకు ఒక్కసారి కాకుండా ప్రతి concurrent request slotకు ఒక్కసారి పరిమాణీకరించబడుతుంది. అందువల్ల Ollamaను ఒకేసారి రెండు promptsకు సమాధానం ఇవ్వనిస్తే, మీరు ఇప్పుడే లెక్కించిన విలువ రెండింతలు అవుతుంది. ఇదే 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 సిగ్నేచర్ లేదా తేదీని ఖచ్చితంగా గుర్తుంచుకోవడం వంటివి దెబ్బతింటాయి. సుదీర్ఘమైన తార్కిక విశ్లేషణలో, రెండో దశలో జరిగే చిన్న పొరపాటు ఎనిమిదో దశలో తప్పుడు సమాధానానికి దారితీస్తుంది. కఠినమైన అవుట్పుట్ ఫార్మాట్లలో, ఒక తప్పుడు బ్రాకెట్ వల్ల టూల్ కాల్ విఫలమవుతుంది.
చివరిగా చెప్పిన అంశమే ఆచరణాత్మక పరీక్ష. మీ కోడ్ పార్స్ చేసే JSON ను మోడల్ తిరిగి ఇవ్వాల్సి వచ్చినప్పుడు, క్వాంటైజేషన్ వల్ల కలిగే నష్టం అస్పష్టమైన వచనంలా కాకుండా, పార్స్ ఎర్రర్గా కనిపిస్తుంది, కాబట్టి మీరు దీన్ని అదే రోజు గమనించవచ్చు. ఒక కోడింగ్ ఏజెంట్ ఈ పరీక్షకు అత్యంత కఠినమైన ఉదాహరణ, ఎందుకంటే ఇది మోడల్ను వరుసగా టూల్ కాల్స్ చేసేలా చేస్తుంది. కాబట్టి మీ Ollama సర్వర్కు ఏజెంట్ను అనుసంధానించడం ద్వారా, అతిగా క్వాంటైజేషన్ చేయడం వల్ల కలిగే నష్టాన్ని మీరు కొన్ని గంటల్లోనే గుర్తించవచ్చు.
నాలుగు బిట్ల కంటే తక్కువకు వెళ్తే నష్టం తీవ్రంగా ఉంటుంది. q3 మరియు రెండు బిట్ల రకాలు చిన్న హార్డ్వేర్పై పెద్ద మోడల్ను నడపాలనుకునే వారి కోసం ఉద్దేశించినవి, మోడల్ను అసలు రన్ చేయలేని పరిస్థితి ఉన్నప్పుడు ఇవి ఒక ప్రత్యామ్నాయం. ఇవి సాధారణ వినియోగానికి తగినవి కావు. q4_K_M మరియు q8_0 మధ్య వ్యత్యాసం చాలా తక్కువ, కాబట్టి ప్రచురించబడిన పర్ప్లెక్సిటీ (perplexity) పట్టికలు మీ పనితీరుకు ఏది సరిపోతుందో నిర్ణయించలేవు, కాబట్టి ఆ పద్ధతిలో ప్రయత్నించకండి. మీ సొంత ప్రాంప్ట్లలో ముప్పైంటిని రెండింటిపై రన్ చేసి, అవుట్పుట్ను స్వయంగా పరిశీలించండి.
q8_0 లేదా fp16 ఎప్పుడు RAMకు విలువైనవిగా ఉంటాయి
మీ దగ్గర మెమరీ నిజంగా ఖాళీగా ఉన్నప్పుడు మరియు చిన్న చిన్న తప్పులు కూడా పనిని దెబ్బతీసే సందర్భాల్లో మాత్రమే q8_0ని ఉపయోగించండి: ఉదాహరణకు స్ట్రక్చర్డ్ ఎక్స్ట్రాక్షన్ (structured extraction), టూల్ కాలింగ్ (tool calling), మరియు కంపైల్ కావాల్సిన కోడ్ వంటివి. మీరు ఇక్కడ ఒక తెలివైన మోడల్ కోసం కాకుండా, తప్పులు జరగకుండా భద్రత కోసం ఖర్చు చేస్తున్నారు.
fp16ని కేవలం రెండు కారణాల కోసం మాత్రమే ఉపయోగించండి. మీరు మోడల్ను మీరే క్వాంటైజ్ (quantize) చేస్తూ సోర్స్ ఫైల్ అవసరమైనప్పుడు, లేదా మీ నాలుగు-బిట్ (four-bit) బిల్డ్ ఎంత నాణ్యతను కోల్పోయిందో తెలుసుకోవడానికి బేస్లైన్ను కొలిచేటప్పుడు మాత్రమే దీన్ని వాడండి. fp16 నుంచి సర్వ్ చేయడం వల్ల q4_K_M కంటే మూడు రెట్లు ఎక్కువ మెమరీ ఖర్చవుతుంది, కానీ చాలా మందికి ఈ రెండింటి మధ్య తేడా తెలియదు. కేవలం CPU మాత్రమే ఉన్న సిస్టమ్లలో ఇది మీ టోకెన్ రేటును మూడవ వంతుకు తగ్గిస్తుంది.
ఒక నిర్ణీత మెమరీ బడ్జెట్ ఉన్నప్పుడు పాటించాల్సిన ముఖ్యమైన నియమం: q4_K_M లో ఉన్న పెద్ద మోడల్ సాధారణంగా q8_0 లో ఉన్న చిన్న మోడల్ కంటే మెరుగ్గా పనిచేస్తుంది. 9.3 GB పరిమాణం గల 14B వెయిట్స్ మరియు 8.9 GB పరిమాణం గల 8B వెయిట్స్ దాదాపు ఒకే రకమైన RAM (random access memory)ను తీసుకుంటాయి, కానీ పెద్ద మోడల్కు ఎక్కువ విషయాలు తెలుసు. దీన్ని ఇతరుల మాటలు నమ్మి కాకుండా, మీ సొంత ప్రాంప్ట్లతో పరీక్షించి చూసుకోండి.
CPU only inference memory bandwidth తో పరిమితమవుతుంది
చాలా VPS plans కు GPU ఉండదు. అందువల్ల model host CPU పై system memory లో నడుస్తుంది. అప్పుడు generation arithmetic వల్ల కాకుండా memory bandwidth వల్ల పరిమితమవుతుంది. ఎందుకంటే ఒక్క token ను ఉత్పత్తి చేయడానికి ప్రతి weight ను ఒకసారి చదవాలి. మీరు ఎన్ని cores కొనుగోలు చేసినా దీనికి సంబంధం లేని ceiling ఏర్పడుతుంది.
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 fp16Dual channel DDR4-3200 host కు Fifty GB/s దాదాపు theoretical figure. VPS ఆ bus ను machine పై ఉన్న ఇతర tenants అందరితో పంచుకుంటుంది కాబట్టి మీకు లభించే share ఇంకా తక్కువగా ఉంటుంది. అందువల్ల ఈ numbers ను ఎవరూ చేరుకోలేని ceiling గా పరిగణించండి. ఉపయోగకరమైన విషయం shape: CPU పై bits per weight ను సగానికి తగ్గిస్తే token rate దాదాపు రెట్టింపు అవుతుంది. GPU లేని machine లో అందుబాటులో ఉన్న అతిపెద్ద speed lever quantization. మీకు మిగిలే rate సహించగలిగేదా అనేది model పై ఆధారపడి ఉంటుంది. VPS పై Nemotron 3.5 Lightning ఒక నిర్దిష్ట build, tag మరియు RAM figure ను కలిపి ఆ లెక్కను చూపిస్తుంది. వేచి ఉండే సమయానికి మరో భాగం model ఎంత రాయాలని నిర్ణయిస్తుందనే దానిపై ఆధారపడి ఉంటుంది. Ten tokens a second వద్ద six hundred token answer కు పూర్తి minute పడుతుంది. అందువల్ల num_predict తో reply ను పరిమితం చేయడం precision ను మరో స్థాయికి తగ్గించడం కంటే తరచుగా ఎక్కువ waiting time ను తిరిగి ఆదా చేస్తుంది.
Prompt processing భిన్నంగా ఉంటుంది. Long prompt ను చదవడం bandwidth bound కాకుండా compute bound అవుతుంది. అందువల్ల అక్కడ extra cores సహాయపడతాయి. Generation speed విషయంలో అవి దాదాపు ఎలాంటి సహాయం చేయవు. 4k prompt ను త్వరగా ingest చేసి, తరువాత నెమ్మదిగా generate చేసే machine సాధారణంగానే పనిచేస్తోంది.
ఈ arithmetic లో ఏదీ పరిశీలించకుండా నమ్మవద్దు. ప్రతి quantization వద్ద అదే prompt తో మీ స్వంత machine పై సెకనుకు tokens ను కొలవండి. మీ numbers వీటిని అధిగమించేలా పరిగణించండి.
మీరు స్వయంగా మోడల్ను quantize చేయడం
మీరు ఏదైనా మోడల్ను fine-tune చేసి ఉంటే, దానికి library tag లేకపోతే ఇది ముఖ్యమైనది. చివరికి మీరు ఉపయోగించాలనుకునే format ఆధారంగా విధానం మారుతుంది. ఎందుకంటే ఈ పేజీ కొలిచే GGUF K-quants ను Ollama ఇప్పుడు తయారు చేయదు.
q4_K_M వంటి K-quant కోసం, Ollama ఫైల్ను స్వీకరించే ముందే quantize చేయాలి. Import సమయంలో Ollama GGUF models ను quantize చేయదు. అలాగే GGUF source పై --quantize ను ఉపయోగించడాన్ని అది నిరాకరిస్తుంది. Unquantized GGUF ను llama.cpp లోని llama-quantize తో quantize చేసి, పూర్తయిన ఫైల్ను import చేయాలి. ఈ import విధానంలో మరో సమస్య ఉంది. Chat template సరిపోకపోతే మోడల్ అర్థంలేని సమాధానాలు ఇస్తుంది. దీన్ని Ollama లోకి GGUF ఫైల్ను import చేయడం వివరంగా చూపిస్తుంది. Import చేసిన ఫైల్ మీరు ఉద్దేశించిన 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 పేర్లను unsupported quantize type error తో నిరాకరిస్తుంది. ఈ types పై పట్టికల్లోని 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 వేగానికి దగ్గరగా పడిపోతుంది, ఎందుకంటే ప్రతి token నెమ్మదిగా ఉన్న సగం భాగం కోసం వేచి ఉంటుంది. కాంటెక్స్ట్ విండోను తగ్గించండి, cache ను క్వాంటైజ్ చేయండి లేదా చిన్న బిల్డ్ను ఉపయోగించండి. కోర్లను పెంచడం వల్ల ప్రయోజనం ఉండదు.
లోడ్ అవుతున్నప్పుడు మోడల్ నిలిపివేయబడుతుంది (killed). కెర్నల్ మరియు సర్వీస్ లాగ్ను తనిఖీ చేయండి:
sudo dmesg -T | grep -i "out of memory"
sudo journalctl -u ollama -n 50Out of memory: Killed process ఉన్న లైన్ అంటే weights, KV cache మరియు బఫర్ల మొత్తం మెమరీ పరిమితిని దాటిందని అర్థం. Swap కాన్ఫిగర్ చేయని VPSలో, ఆ లైన్ కనిపించే ముందు మొత్తం మెషిన్ కొన్ని సెకన్ల పాటు నిలిచిపోవచ్చు.
మీరు ఏమీ మార్చకపోయినా సమాధానాలు నాణ్యత తగ్గింది. ఒకే మోడల్ యొక్క రెండు బిల్డ్లు ollama ls లో వేర్వేరు ట్యాగ్ల కింద పక్కపక్కనే ఉండవచ్చు, మరియు సఫిక్స్ లేని పేరును పుల్ చేసే స్క్రిప్ట్ లైబ్రరీ దేనిని సూచిస్తే దానిని అనుసరిస్తుంది. మీ క్లయింట్ అభ్యర్థించే ఖచ్చితమైన ట్యాగ్పై ollama show రన్ చేయండి మరియు quantization లైన్ను చదవండి, అంతే కానీ మీ కాన్ఫిగరేషన్ ఫైల్లోని పేరును నమ్మకండి.
FAQ
నేను ఏ Ollama quantization ను pull చేయాలి?
q4_K_M తో ప్రారంభించండి. చాలా మోడల్స్కు Ollama లైబ్రరీ డిఫాల్ట్ ట్యాగ్గా దీనినే అందిస్తుంది, కాబట్టి ollama pull qwen3:8b మరియు ollama pull qwen3:8b-q4_K_M రెండూ ఒకే ఫైల్ను డౌన్లోడ్ చేస్తాయి. మెమరీ ఎక్కువగా ఉన్నప్పుడు మరియు టూల్ కాలింగ్ (tool calling) లేదా స్ట్రక్చర్డ్ JSON అవుట్పుట్ వంటి చిన్న తప్పులను కూడా సహించని పనుల కోసం మాత్రమే q8_0 కి మారండి. మెమరీ బడ్జెట్ పరిమితంగా ఉన్నప్పుడు, సాధారణంగా చిన్న మోడల్ q8_0 కంటే పెద్ద మోడల్ q4_K_M మెరుగైన ఫలితాలను ఇస్తుంది, కాబట్టి RAM ను ఖర్చు చేసే ముందు ఈ రెండింటిని పరీక్షించండి.
q4_K_M అంటే నిజంగా ప్రతి వెయిట్కు నాలుగు బిట్లు అని అర్థమా?
కాదు. Llama 3.1 8B పై కొలిచినప్పుడు ఇది 4.89 బిట్లుగా ఉంటుంది, ఎందుకంటే ప్రతి వెయిట్ బ్లాక్ తన సొంత స్కేల్ను కలిగి ఉంటుంది మరియు అత్యంత ముఖ్యమైన టెన్సర్లు (tensors) అధిక బిట్ రకానికి మార్చబడతాయి. ఇదే కారణంతో Q8_0 కూడా ఎనిమిది బిట్లకు బదులుగా 8.5 బిట్లను కలిగి ఉంటుంది. అంచనా వేసేటప్పుడు ఈ కొలతను ఉపయోగించండి: పారామీటర్ల సంఖ్యను ప్రతి వెయిట్ బిట్లతో గుణించి, ఎనిమిదితో భాగిస్తే వచ్చే విలువ ఫైల్ సైజును బైట్లలో తెలియజేస్తుంది.
CPU మాత్రమే ఉన్న VPSలో 8B మోడల్కు ఎంత RAM అవసరం?
వెయిట్స్, KV క్యాష్ మరియు అదనపు మెమరీని పరిగణనలోకి తీసుకోండి. Qwen3 8B (q4_K_M) వెయిట్స్ పరిమాణం 5.2 GB. డిఫాల్ట్ 4096 టోకెన్ విండో వద్ద, క్యాష్ అదనంగా 0.6 GB తీసుకుంటుంది, దీనివల్ల కంప్యూట్ బఫర్లు మరియు ఆపరేటింగ్ సిస్టమ్కు ముందు కనీసం 5.8 GB RAM అవసరమవుతుంది. 32k విండో వద్ద కేవలం క్యాష్ మాత్రమే 4.83 GB తీసుకుంటుంది. తక్కువ విండో కోసం 8 GB, ఎక్కువ విండో కోసం 16 GB RAM ఉండేలా ప్లాన్ చేసుకోండి.
నా సర్వర్లో GPU ఉన్నప్పటికీ మోడల్ 100% CPUని ఎందుకు వాడుతోంది?
ollama ps రన్ చేసి PROCESSOR కాలమ్ను గమనించండి. 100% CPU, లేదా 48%/52% CPU/GPU వంటి విభజన కనిపిస్తే, వెయిట్స్ మరియు KV క్యాష్ VRAMలో సరిపోలేదని అర్థం. అప్పుడు Ollama మోడల్లో కొంత భాగాన్ని లేదా మొత్తాన్ని సిస్టమ్ మెమరీలో ఉంచుతుంది. మోడల్ లోడ్ అయినప్పుడు మొత్తం విండో కోసం క్యాష్ కేటాయించబడుతుంది కాబట్టి, గ్రాఫిక్స్ కార్డ్ సామర్థ్యం కంటే పెద్ద కాంటెక్స్ట్ విండో ఉండటం దీనికి ప్రధాన కారణం. OLLAMA_CONTEXT_LENGTH తో విండోను తగ్గించండి, OLLAMA_KV_CACHE_TYPE=q8_0 ద్వారా క్యాష్ను సగానికి తగ్గించండి లేదా చిన్న quantization మోడల్ను pull చేయండి.