Ollamaతో GPU లేని VPSలో Qwen 3.8 27B ఎలా నడపాలి
`qwen3.8:27b` కోసం Ollama v0.32.12 లేదా తర్వాతి వెర్షన్ అవసరం. CPU-only VPSలో RAM లెక్కలు, వేగం, 8 నుంచి 64 GBలో ఏది సరిపోతుందో తెలుసుకోండి.
GPU లేని VPSలో Qwen 3.8 27B ను నడపగలరా?
VPSలో Qwen 3.8 27B ను నడపడానికి qwen3.8:27b tag అవసరం. 21 October 2026 నాటికి Ollama libraryలో దీన్ని స్థానికంగా pull చేయగల tagగా అందిస్తున్నారు: 27.3 billion parameters, Q4_K_M quantisation, Apache 2.0 licence, 256K context window, అలాగే సుమారు 0.9 GB vision projectorతో కలిపి 18 GB download. Ollama, 14 August 2026న విడుదలైన v0.32.12లో Qwen 3.8 27B supportను చేర్చింది. కాబట్టి పాత installation ఉంటే ముందుగా upgrade చేయాలి. 29 October 2026 నాటికి latest stable release v0.40.13; ఇది 28 October 2026న ప్రచురించబడింది.
సంక్షిప్త సమాధానం: 32 GB లేదా అంతకంటే ఎక్కువ RAM ఉన్న VPSలో నడపవచ్చు, కానీ నెమ్మదిగా ఉంటుంది. Q4లో ఉన్న 27B dense modelకు weights కోసం మాత్రమే సుమారు 17 GB RAM అవసరం. ఇందులో ఒక్క context token కూడా ఇంకా నిల్వ కాలేదు. అందువల్ల 8 GB మరియు 16 GB plans పూర్తిగా సరిపోవు. సాధారణ two-channel DDR4 VPSలో గరిష్ఠ వేగం సుమారు 3 tokens per second ఉంటుంది. ఇది చాలామంది చదివే వేగం కంటే నెమ్మదిగా ఉంటుంది.
మునుపటి 27B tags libraryలో ఇంకా ఉన్నాయి: qwen3.6:27b మరియు qwen3.5:27b రెండూ సమాన పరిమాణం కలిగిన Q4_K_M builds. Qwen3.8-27B, Qwen3.6-27B యొక్క architectureను కొనసాగిస్తుంది. ఈ రెండింటి official config filesలో layer layout ఒకే విధంగా ఉంది. కాబట్టి దిగువ memory లెక్కలు రెండింటికీ వర్తిస్తాయి. ఏ commandను copy చేయడానికి ముందు live listను Ollama qwen3.8 tag pageలో తనిఖీ చేయండి. ఇక్కడి లెక్కలు version numberపై కాకుండా parameter count, bits per weight మరియు attention layoutపై ఆధారపడతాయి.
ఏ Ollama tag ను pull చేయాలి, దాన్ని ఎలా తనిఖీ చేయాలి
లేని tag ను pull చేస్తే స్పష్టమైన error వస్తుంది. అందువల్ల దీన్ని అదే server పై త్వరగా నిర్ధారించవచ్చు. ఉన్న tag అయినప్పటికీ local గా run చేయలేకపోవచ్చు. libraryలో జాబితా చేయబడినప్పటికీ Ollama cloud నుంచి మాత్రమే అందించబడే GLM 5.2 విషయంలో చాలామందికి సమస్య ఇక్కడే వస్తుంది.
ollama --version
ollama pull qwen3.8:27b
ollama show qwen3.8:27bollama show మీరు నిజంగా పొందిన tag కు సంబంధించిన architecture, parameter count, context length మరియు quantisation ను చూపిస్తుంది. Parameter line 27.3B గా, quantisation line Q4_K_M గా ఉంటే, ఈ guide ఆధారపడిన build మీ వద్ద ఉంది. అదే weights కు అధిక precisionలో qwen3.8:27b-q8_0 మరియు qwen3.8:27b-bf16 కూడా libraryలో ఉన్నాయి. అదనంగా 27b-mtp variants, అలాగే tags page MLXగా పేర్కొనే 27b-nvfp4, 27b-mxfp8, 27b-mlx మరియు 27b-mlx-bf16 tags కూడా ఉన్నాయి. MLX format Linux VPS కంటే Apple Silicon కోసం ఉద్దేశించబడింది. qwen3.6 కు భిన్నంగా, qwen3.8 entryలో 35b-a3b tags లేవు. ఆ MoE (mixture of experts) models ఇప్పటికీ qwen3.6 కిందనే ఉంటాయి. CPUపై వాటి ప్రవర్తన చాలా భిన్నంగా ఉంటుంది. వాటి గురించి క్రింద మరింత వివరించాం.
ప్రతి weightకు bytes ఆధారంగా parameter count
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "Q4_K_M",
"size_gb": 17,
"bits_per_weight": 4.98,
"notes": "published tag qwen3.8:27b, language model file"
},
{
"label": "Q5_K_M",
"size_gb": 19.5,
"bits_per_weight": 5.7,
"notes": "computed, no official library tag exists"
},
{
"label": "NVFP4",
"size_gb": 18,
"bits_per_weight": 5.27,
"notes": "published tag 27b-nvfp4, MLX build, one file including the vision encoder"
},
{
"label": "Q8_0",
"size_gb": 29,
"bits_per_weight": 8.5,
"notes": "published tag 27b-q8_0, language model file"
},
{
"label": "BF16",
"size_gb": 55,
"bits_per_weight": 16.1,
"notes": "published tag 27b-bf16, language model file"
}
]సూత్రం ఒకే పంక్తిలో ఉంటుంది. Weights యొక్క bytes = parameters * ప్రతి weightకు bits / 8. ఖచ్చితమైన 4 bits వద్ద, 27.3 billion parameters విలువ 13.7 GB అవుతుంది. పంపిణీ చేసిన Q4_K_M tag లోని language model file పరిమాణం 17 GB. అంటే ఆచరణలో ప్రతి weightకు 4.98 bits ఉంటాయి.
ఆ తేడా లోపం కాదు. K-quant formats ప్రతి tensor ను nominal width తో నిల్వ చేయవు. Compression వల్ల నాణ్యత ఎక్కువగా తగ్గే tensors కు ఎక్కువ bits కేటాయిస్తాయి. పంపిణీ చేసిన qwen3.8:27b file కోసం Ollama tensor listing లో ఇవి Q6_K వద్ద ఉన్నాయి: output layer, feed-forward down projections లో సుమారు సగం, full-attention layers లో సుమారు సగం భాగంలోని attention V projections, అలాగే linear-attention layers లో fused QKV projections లో సుమారు సగం. చిన్న normalisation tensors పూర్తి 32-bit precision వద్దనే ఉంటాయి. Token embedding, attention Q మరియు K projections, feed-forward gate మరియు up projections మోడల్లోని ఎక్కువ భాగంలానే Q4_K వద్ద ఉంటాయి. Format పేరులోని సంఖ్య సగటును సూచిస్తుంది. ఆ సగటు 5కు సమీపంగా ఉంటుంది. Scale యొక్క మరో చివరలో కూడా ఇదే ప్రభావం కనిపిస్తుంది: BF16 కోసం 55 GB అంటే ప్రతి weightకు flat 16 bits కాకుండా 16.1 bits ఉంటాయి. అక్కడ token embedding కూడా మిగతా అన్నింటిలాగే BF16లో ఉంటుంది. స్వల్ప అదనపు పరిమాణం file metadata, 32-bit వద్ద ఉంచిన normalisation tensors, మరియు సమీప gigabyteకు round చేసిన పరిమాణం వల్ల వస్తుంది.
Language model file పరిమాణానికే కాకుండా మొత్తం tag పరిమాణానికి బడ్జెట్ కేటాయించండి. qwen3.8:27b లోని ప్రతి GGUF tag సుమారు 0.9 GB పరిమాణం గల vision projector ను కూడా ship చేస్తుంది. అందుకే Q4_K_M tag 18 GBగా చూపబడుతుంది.
అధికారిక qwen3.8 library entryలో Q5_K_M కోసం published tag లేదు. అందువల్ల 19.5 GB row ను కొలిచిన పరిమాణం ఆధారంగా కాకుండా, ఆ formatకు సాధారణమైన ప్రతి weightకు 5.7 bits ఆధారంగా లెక్కించారు. Q8_0, Q4తో పోలిస్తే దాదాపు రెండింతలు పెరిగి 29 GB అవుతుంది. CPU-only boxలో ఆ పెరుగుదల ప్రతి tokenకు memory traffic ను రెండింతలు చేస్తుంది. అందువల్ల tokens per second కూడా సుమారు సగానికి తగ్గుతుంది. ఈ కారణం ఒక్కటే చూసినా ఇక్కడ Q4_K_M సరైన default. Memory కంటే quality పరంగా ఆ నిర్ణయం ఎలా ఉంటుందో చూడాలనుకుంటే, Q4, Q8 మరియు fp16 మధ్య మరింత సమీప పోలిక output వాస్తవంగా ఎక్కడ degrade అవుతుందో చూపిస్తుంది.
సందర్భ పరిమాణం పెరిగేకొద్దీ KV cache ఖర్చు
Weights ఒక స్థిరమైన ఖర్చు. KV cache (key మరియు value cache; మోడల్ ఇప్పటికే చూసిన ప్రతి token కోసం ఉంచే attention state) context length పెరిగేకొద్దీ సరళరేఖలో పెరుగుతుంది. వాస్తవంగా ఎక్కువమంది RAM అయిపోవడానికి ఇదే ప్రధాన కారణం.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "4k tokens",
"kv_f16_gb": 0.25,
"kv_q8_gb": 0.13
},
{
"label": "8k tokens",
"kv_f16_gb": 0.5,
"kv_q8_gb": 0.25
},
{
"label": "16k tokens",
"kv_f16_gb": 1,
"kv_q8_gb": 0.5
},
{
"label": "32k tokens",
"kv_f16_gb": 2,
"kv_q8_gb": 1
},
{
"label": "64k tokens",
"kv_f16_gb": 4,
"kv_q8_gb": 2
},
{
"label": "128k tokens",
"kv_f16_gb": 8,
"kv_q8_gb": 4
}
]ఈ గణాంకాలు మోడల్ స్వంత config file నుంచి వచ్చాయి. Qwen3.8-27B, Qwen3.6-27B లాగే, hybrid-attention model. దాని 64 layersలో 16 మాత్రమే full attention ఉపయోగిస్తాయి. ప్రతి tokenతో పెరిగే cache ను ఈ layers మాత్రమే ఉంచుతాయి. ఈ layersలో GQA (grouped-query attention) కింద 4 key/value heads, అలాగే 256 head dimension ఉన్నాయి. మిగిలిన 48 layers linear attention (Gated DeltaNet) ఉపయోగిస్తాయి. అందువల్ల ఇవి స్థిర పరిమాణం గల state ను ఉంచుతాయి. నా లెక్క ప్రకారం context ఎంత పెరిగినా, ప్రతి conversation slotకు ఇది సుమారు 150 MB ఉంటుంది. f16లో ప్రతి tokenకు 64 KiB అవుతుంది. కాబట్టి 32k tokens వద్ద 2 GB, 128k వద్ద 8 GB అవుతుంది. మీ స్వంత machineలో నా లెక్కను తనిఖీ చేయకుండా నేరుగా నమ్మవద్దు. మోడల్ను load చేసి, ollama psలోని SIZE columnను చదవండి. ఇది weights, cache, overhead మొత్తాన్ని ఒకే సంఖ్యగా చూపిస్తుంది.
Model cardలోని 256K context ఈ architectureలో సాధ్యమే. అయితే అది ఉచితం కాదు. దీన్ని f16లో పూర్తిగా నింపడానికి weightsకు అదనంగా సుమారు 16 GB cache అవసరం. ఈ machine ఇప్పటికే weights కోసం 17 GB ఉపయోగించింది. Ollama పూర్తి windowను defaultగా ఇవ్వదు. దాని context-length documentation ప్రకారం VRAM ఆధారంగా default ఇలా ఉంటుంది: 24 GiB కంటే తక్కువకు 4k tokens, 24 నుంచి 48 GiB వరకు 32k, 48 GiB లేదా అంతకంటే ఎక్కువకు 256k. CPU-only VPSలో VRAM అసలు ఉండదు. అందువల్ల అది 4k tierలో ఉంటుంది. OLLAMA_CONTEXT_LENGTH ద్వారా మీరు దీన్ని ఉద్దేశపూర్వకంగా పెంచవచ్చు. ఈ server-wide variable ఒక్కటే నియంత్రణ కాదు. వ్యక్తిగత requestలో num_ctx అమర్చడం ద్వారా మిగతా వాటికి తక్కువ ఖర్చుతో కూడిన defaultను ఉంచి, ఒక పొడవైన jobకు మాత్రమే పెద్ద window ఇవ్వవచ్చు. దీన్ని దశలవారీగా పెంచి, ప్రతి మార్పు తర్వాత ollama psను తనిఖీ చేయండి.
Cache పరిమాణాన్ని తగ్గించడానికి రెండు settings ఉపయోగపడతాయి. OLLAMA_KV_CACHE_TYPE=q8_0 cacheను 16 bitsకు బదులుగా 8 bitsలో నిల్వ చేస్తుంది. అందువల్ల 32k tokens వద్ద cache 2 GB నుంచి 1 GBకు తగ్గుతుంది. దీనికి flash attention అవసరం. కాబట్టి OLLAMA_FLASH_ATTENTION=1ను కూడా సెట్ చేసి, అది వర్తించిందని ఊహించకుండా ollama psలో తగ్గుదలను నిర్ధారించండి. మీరు ఇంతకుముందు cache typeను మార్చకపోతే, Ollama KV cacheలో q8_0ను f16తో పోల్చే మార్గదర్శకం రెండు variablesను సెట్ చేయడం, మార్పుకు ముందు మరియు తర్వాతి గణాంకాలను చదవడం వివరిస్తుంది. OLLAMA_NUM_PARALLEL=1 కూడా అంతే ముఖ్యమైనది. Ollama ఒకేసారి అనేక requestsను serve చేయగలదు. ప్రతి slotకు contextలో తన స్వంత భాగం ఉంటుంది. అందువల్ల parallelismను పెంచితే, మీరు బడ్జెట్ చేసిన cache నిశ్శబ్దంగా అనేక రెట్లు పెరుగుతుంది. ప్రస్తుత default ఇప్పటికే 1గా ఉంది. దిగువ override దానిని 1గానే ఉంచుతుంది. ఈ machineను ఒకరి కంటే ఎక్కువమంది ఉపయోగిస్తే, సమస్య అక్కడే మొదలవుతుంది. Self-hosted model ఏకకాలంలో ఎన్ని usersను serve చేయగలదో core count కంటే చాలా ముందుగానే cache slots మరియు queue depth నిర్ణయిస్తాయి. self-hosted model serve చేయగల concurrent users సంఖ్య దీనిని వివరిస్తుంది.
8, 16, 32 మరియు 64 GB RAMలో ఏమి సరిపోతుంది
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "8 GB",
"q4_max_ctx_ktok": 0,
"q8_max_ctx_ktok": 0,
"notes": "Weights alone exceed the box. Use a 4b or 8b model."
},
{
"label": "16 GB",
"q4_max_ctx_ktok": 0,
"q8_max_ctx_ktok": 0,
"notes": "17 GB of weights does not fit in 16 GB of RAM."
},
{
"label": "32 GB",
"q4_max_ctx_ktok": 128,
"q8_max_ctx_ktok": null,
"notes": "Q4 fits with room for long context. Q8 weights fit, but usable context needs a measured total memory budget."
},
{
"label": "64 GB",
"q4_max_ctx_ktok": 256,
"q8_max_ctx_ktok": 256,
"notes": "Both fit with the full 256K window."
}
]Weights మరియు vision projector తో పాటు, f16 cache ఉపయోగించి, headless Linux VPSలో operating system కోసం సుమారు 1.5 GB మరియు కొంత అదనపు మార్జిన్ మిగిలేలా సరిపడే context యొక్క వేలాది tokensగా ఈ రెండు సంఖ్యలను చదవండి. Zero అంటే weightsకే స్థలం సరిపోదని అర్థం, కాబట్టి ఏదీ సరిపోదు; null అంటే weights సరిపోతాయి, కానీ ఆ tierకు ఉపయోగించగల context సంఖ్య నిర్ధారించబడలేదని అర్థం.
8 GB మరియు 16 GB మధ్య ఇది స్వల్ప తేడా కాదు. 17 GB weights 16 GB RAMలో సరిపోవు. ఏ context setting దీనిని మార్చదు. Swap జోడించినా సమస్య పరిష్కారం కాదు. Ollama GGUF fileను memory-map చేస్తుంది. అందువల్ల resident pages RAMను మించగానే kernel వాటిని తొలగించి మళ్లీ చదవడం ప్రారంభిస్తుంది. అప్పుడు ప్రతి token కోసం disk నుంచి gigabytes చదవాల్సి వస్తుంది. Boxలో iowait అధికంగా ఉంటుంది. వేగం ప్రతి సెకనుకు ఒక tokenకంటే చాలా తక్కువగా ఉంటుంది.
32 GB ప్రారంభ స్థాయి. Weights 17 GB తీసుకుంటాయి. vision projector సుమారు 0.9 GB జోడిస్తుంది. మీకు దాదాపు 12.5 GB మిగులుతుంది. ఇది మార్జిన్తో సుమారు 128k tokens f16 contextకు సరిపోతుంది. 29 GB పరిమాణంలోని Q8_0 weights 32 GBలో సరిపోతాయి. అయితే ఉపయోగించగల context vision projector, cache, operating system మరియు runtime memoryపై కూడా ఆధారపడి ఉంటుంది. ఈ tierలో Q8 నడుస్తుందని నిర్ణయించే ముందు, మీ boxలో మొత్తం memory footprintను తనిఖీ చేయండి.
64 GB సౌకర్యవంతంగా ఉంటుంది. Q4తో పూర్తి 256k windowకు స్థలం ఉంటుంది. Q8_0 weights కూడా వాటి వెనుక పూర్తి 256k contextతో సరిపోతాయి. Q8 కోసం 64 GBకు చెల్లించే ముందు, మీరు ఏమి కొనుగోలు చేస్తున్నారో స్పష్టంగా తెలుసుకోండి: వేగం సగానికి తగ్గినప్పటికీ outputలో స్వల్ప మెరుగుదల మాత్రమే. అదే machine ఇప్పటికే నెమ్మదిగా ఉంది. 32 GB planలోనే Q4 128k tokensకు చేరుతుంది. దాదాపు అందరికీ అదే మెరుగైన ఎంపిక.
VPSలో CPU inference ఎంత వేగంగా ఉంటుంది?
Dense model నుంచి ఒక token రూపొందించడానికి ప్రతి weight ను memory నుంచి ఒక్కసారి చదవాలి. కొన్నింటిని కాదు. అన్నింటినీ. అందువల్ల వేగ పరిమితి మీ core count కాదు; weights పరిమాణంతో భాగించిన memory bandwidth. Q4 వద్ద ప్రతి token కు 17 GB memory traffic అవసరం.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "DDR4-2666, 2 channel",
"mem_bandwidth_gb_s": 42.6,
"ceiling_tok_s": 2.5
},
{
"label": "DDR4-3200, 2 channel",
"mem_bandwidth_gb_s": 51.2,
"ceiling_tok_s": 3
},
{
"label": "DDR5-4800, 2 channel",
"mem_bandwidth_gb_s": 76.8,
"ceiling_tok_s": 4.5
},
{
"label": "DDR4-3200, 8 channel",
"mem_bandwidth_gb_s": 204.8,
"ceiling_tok_s": 12
},
{
"label": "DDR5-4800, 12 channel",
"mem_bandwidth_gb_s": 460.8,
"ceiling_tok_s": 27.1
}
]అవి కొలిచిన వేగాలు కాదు, గరిష్ఠ అంచనాలు. వాస్తవ output సాధారణంగా చూపిన విలువలో 50 నుంచి 70 శాతం ఉంటుంది. దీనికి కారణం memory latency మరియు పూర్తిగా సమర్థవంతంగా జరగని prefetching. అందువల్ల theoretical peak ను చేరుకోలేరు. రెండు-channel DDR4-3200 VPS ceiling 3 tokens per second. కాబట్టి సుమారు 2 tokens per second ఆశించాలి. రెండు-channel DDR5-4800 server ceiling 4.5. కాబట్టి సుమారు 3 tokens per second ఆశించాలి.
పెద్ద server వరుసల విషయంలో ఒక ముఖ్యమైన హెచ్చరిక ఉంది. పన్నెండు-channel EPYC platform వద్ద 460.8 GB/s memory bandwidth మరియు 27.1 tokens per second ceiling ఉంటుంది. కానీ మీరు మొత్తం EPYC server ను rent చేయరు. Memory bandwidth ఆ machine పై ఉన్న ప్రతి tenant పంచుకునే host-wide resource. అందువల్ల 8 vCPU slice కు పన్నెండు exclusive bandwidth channels లభించవు. GPUపై దృష్టి పెట్టిన guides ఈ విషయాన్ని పూర్తిగా వదిలేస్తాయి. అదే model పై identical vCPU counts ఉన్న రెండు VPS plans వేగంలో మూడు రెట్లు తేడా చూపించడానికి ఇదే కారణం.
అదే కారణంతో ఎక్కువ vCPUs త్వరగానే ఉపయోగం లేకుండా పోతాయి. Cores memory controller అందించగల వేగం కంటే data ను వేగంగా కోరడం ప్రారంభించిన తర్వాత, అదనపు threads scheduling overhead ను మాత్రమే పెంచుతాయి. Ollamaలో thread count కోసం server-wide environment variable లేదు. అందువల్ల request options లో num_thread ను మీ physical core count కు సెట్ చేసి కొలవండి. తరువాత ఆ సంఖ్యలో సగాన్ని ప్రయత్నించండి. అనేక shared plansలో తక్కువ setting వేగంగా ఉంటుంది.
Prompt processing భిన్నంగా పనిచేస్తుంది. మొదటి token కనిపించే ముందు input మొత్తంపై జరిగే pass అయిన prefill, bandwidth-bound కాకుండా compute-bound గా ఉంటుంది. అందువల్ల ఇది cores పెరిగే కొద్దీ scale అవుతుంది. దీని ప్రాయోగిక ప్రభావం ఏమిటంటే పెద్ద prompt కు output ప్రారంభమయ్యే ముందు ఎక్కువ విరామం ఉంటుంది. ఆ తరువాత పైన పేర్కొన్న స్థిరమైన నెమ్మది వేగం వస్తుంది. ప్రతి request కు ఒక prompt eval rate మరియు ఒక eval rate ను ముద్రించే --verbose తో ఈ రెండు దశల సమయాన్ని విడిగా కొలవండి.
Dense 27B చాలా నెమ్మదిగా ఉంటే, CPUను వదిలేయడానికి ముందు qwen3.6:35b-a3b tags ను పరిశీలించండి. ఇవి ప్రతి token కు మొత్తం 27.3 billion parameters బదులుగా సుమారు 3 billion parameters ను మాత్రమే activate చేస్తాయి. అందువల్ల diskలోని file పెద్దదిగా ఉన్నప్పటికీ, ప్రతి token కు memory traffic దాదాపు ఒక order of magnitude తగ్గుతుంది. RAM footprintకు బదులుగా వేగాన్ని ఎంచుకుంటారు. ఇక్కడ runtime ఎంపిక కూడా ముఖ్యమే. అదే underlying inference code పై Ollama మరియు llama.cpp వేర్వేరు CPU tuning controls ను అందిస్తాయి.
GPU గంటను అద్దెకు తీసుకోవాల్సిన సందర్భం
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "L40S, 48 GB",
"mem_bandwidth_gb_s": 864,
"ceiling_tok_s": 51
},
{
"label": "RTX 4090, 24 GB",
"mem_bandwidth_gb_s": 1008,
"ceiling_tok_s": 59
},
{
"label": "A100, 80 GB",
"mem_bandwidth_gb_s": 2039,
"ceiling_tok_s": 120
},
{
"label": "H100 SXM, 80 GB",
"mem_bandwidth_gb_s": 3350,
"ceiling_tok_s": 197
}
]ప్రచురించిన GPU memory bandwidth కు ఇదే సూత్రాన్ని వర్తింపజేస్తే, వేరే రకమైన సమాధానం లభిస్తుంది. 24 GB consumer card ఈ weights పై సెకనుకు 59 tokens వరకు మాత్రమే అందిస్తుంది. ప్రస్తుత data centre card 197 వరకు చేరుతుంది. Thread counts ను సర్దుబాటు చేయడం ద్వారా ఈ అంతరాన్ని భర్తీ చేయలేరు. మీ VPS tens GB/s వద్ద నడుస్తుంటే, ఆ card memory 1008 GB/s వద్ద నడుస్తుంది.
కాబట్టి ప్రాధాన్యత ఆధారంగా కాకుండా workload ఆధారంగా నిర్ణయించండి. పని asynchronous గా ఉండి, దాని కోసం ఎవరూ వేచి ఉండకపోతే CPU inference సరైన ఎంపిక: ఉదాహరణకు, రాత్రంతా document pile ను summarise చేయడం లేదా మీరు నిద్రిస్తున్న సమయంలో nightly classification job ను అమలు చేయడం. ఎవరైనా output కోసం వేచి ఉన్నప్పుడు, లేదా మీ box పూర్తి చేయగల వేగం కంటే requests వేగంగా వచ్చినప్పుడు GPU ను అద్దెకు తీసుకోండి. CPU runtimes ఒకేసారి ఒక request కు మాత్రమే పరిమితం కావు: llama.cpp server CPUతో పాటు GPUపై కూడా parallel decoding మరియు continuous batching ను document చేస్తుంది. Ollama కూడా parallel requests ను serve చేయగలదు, అయితే దీనికి మరింత cache అవసరం. మీ measured serving rate ను arrival rate తో పోల్చినప్పుడు వచ్చిన ఫలితమే నిర్ణయాత్మకం. అందువల్ల మీ స్వంత box పై వాస్తవిక batch ను time చేయండి. Requests ఆ రేటు కంటే వేగంగా రావడం ప్రారంభించిన వెంటనే queue పెరుగుతుంది.
ఖర్చు పోలిక కనిపించేదానికంటే అంత సులభం కాదు. Model loaded అయి ఉన్నా లేకపోయినా 64 GB VPS నెలలోని ప్రతి గంటకు billing చేస్తుంది. దీనికి విరుద్ధంగా, hourly GPU rental compute charges ను storage charges నుంచి వేరు చేస్తుంది; GPU ఆగిపోయిన తర్వాత కూడా storage charges కొనసాగవచ్చు. మీ వాస్తవ వినియోగం రోజుకు రెండు గంటలు మాత్రమే అయితే, అద్దె GPU వేగంగా ఉండటంతో పాటు చౌకగానూ ఉండవచ్చు. ముందుగా మీ duty cycle ను లెక్కించండి. తరువాత ఖర్చును అంచనా వేయండి. GPU ఉన్న VPS ను ఎంచుకునేటప్పుడు పరిశీలించాల్సిన అంశాలు instance పైనే ఏమి పరిశీలించాలో వివరిస్తుంది. GPUపై concurrent requests ను serve చేసినప్పుడు GPUపై concurrent requests ను serve చేస్తే vLLM, Ollama కంటే ముందుంటుంది, ఎందుకంటే అది వాటిని సరిగ్గా batch చేస్తుంది.
ప్రజలు తరచుగా మరచిపోయే మూడవ ఎంపిక కూడా ఉంది. Batch పని కోసం 27B ను CPUపై ఉంచి, interactive path ముందు hosted API model ను ఉంచండి. రెండు పనులకు ఒకే model ను ఉపయోగించాల్సిన అవసరం లేదు.
Ollamaను ఇన్స్టాల్ చేసి, మీ స్వంత సిస్టమ్ను కొలవండి
ఇన్స్టాల్ స్క్రిప్ట్ అధికారికమైనది. ఇది ప్రత్యేకమైన ollama user గా నడిచే systemd service ను ఏర్పాటు చేస్తుంది.
curl -fsSL https://ollama.com/install.sh | sh
ollama --version
free -gollama --version తప్పనిసరిగా 0.32.12 లేదా ఆ తర్వాతి version ను చూపాలి. Qwen 3.8 27B support కలిగిన మొదటి release ఇదే. ఏదైనా download చేయడానికి ముందు free -g ను పరిశీలించండి. ఇది GiBలో చూపుతుంది. అందువల్ల 32 GB RAMగా ప్రకటించిన plan, total columnలో సుమారు 29గా కనిపించవచ్చు. అందుబాటులో ఉన్న memoryని పై పేర్కొన్న weights మరియు cache budgetతో పోల్చండి.
Runtime options ను మీ shellలో కాకుండా systemd overrideలో సెట్ చేయండి. Model service లోపల నడుస్తుంది. అందువల్ల అది మీ interactive environmentను చూడదు.
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
Environment="OLLAMA_KEEP_ALIVE=60m"sudo systemctl restart ollama
ollama pull qwen3.8:27b
ollama run qwen3.8:27b --verbose "Name two Linux distributions."--verbose output మీరు కొలవాల్సిన ప్రధాన ఫలితం. eval rate generation సమయంలో మీ tokens per second. prompt eval rate prefill speed. load duration disk నుంచి weights చదవడానికి పట్టిన సమయం. అందుకే OLLAMA_KEEP_ALIVE=60m సెట్ చేయబడింది. CPUపై ప్రతి requestకు disk నుంచి 17 GB మళ్లీ చదవడం, ఆ requestను process చేయడం కంటే ఎక్కువ సమయం తీసుకుంటుంది. Default idle timeout ఐదు నిమిషాలు. Items మధ్య విరామాలు ఉన్న batch queue ఈ load costను పదేపదే చెల్లించేంత తక్కువ సమయం ఇది. modelను residentగా ఉంచే options ప్రతి-requestలోని keep_alive fieldను సెట్ చేయడం, అలాగే reboot తర్వాత కూడా ఆ setting కొనసాగించడం రెండింటినీ వివరిస్తాయి.
Model load అయి ఉన్నప్పుడు, రెండో terminal నుంచి memory footprintను పరిశీలించండి.
ollama psSIZE columnలో KV cacheతో సహా వాస్తవ memory footprint కనిపిస్తుంది. ఇది weights, vision projector, అలాగే KV chartలో మీ context lengthకు సంబంధించిన row మొత్తానికి దగ్గరగా ఉండాలి. 8192 tokens వద్ద 8-bit cache ఉపయోగిస్తే, cacheలో పెరుగుతున్న భాగం సుమారు quarter gigabyte మాత్రమే ఉంటుంది. అది f16గా కొనసాగితే 0.5 GB అయ్యేది. దీనికి fixed linear-attention state అదనంగా ఉంటుంది. PROCESSOR columnలో 100% CPU కనిపించాలి. వేరేదైనా కనిపిస్తే, ఏదో ఒకటి GPUను ఉపయోగిస్తోంది. అప్పుడు ఈ guideలోని speed numbers మీ సిస్టమ్కు వర్తించవు.
మీరు చూసే వైఫల్య పరిస్థితులు మరియు ఖచ్చితమైన సందేశాలు
మోడల్ లోడ్ కావడం లేదు. Ollama రెండు గణాంకాలకు పేర్లు ఇచ్చే ఒక పంక్తిని model requires more system memory (18.6 GiB) than is available (15.2 GiB) రూపంలో చూపిస్తుంది. ఇది మంచిదైన వైఫల్యం, ఎందుకంటే kernel కేటాయింపును నిర్వహించే వరకు వేచి ఉండకుండా Ollama ముందుగానే తనిఖీ చేసింది. context length తగ్గించండి, చిన్న tag కు మారండి లేదా ఎక్కువ సామర్థ్యం ఉన్న plan ను ఎంచుకోండి.
సమాధానం మధ్యలో process కనుమరుగవుతుంది. client ఉపయోగకరమైనదేమీ చూపించదు, మరియు journalctl -u ollama -n 50 service మళ్లీ ప్రారంభమవుతున్నట్లు చూపిస్తుంది. dmesg -T | tail అమలు చేయండి. Out of memory: Killed process ... (ollama) చదివే పంక్తి కనిపిస్తే kernel OOM killer దాన్ని నిలిపివేసిందని అర్థం. ముందస్తు లోడ్ తనిఖీ విజయవంతమైనప్పటికీ, దీర్ఘ సంభాషణలో cache అంచనాను మించి పెరిగినప్పుడు ఇది జరుగుతుంది. context length తగ్గించండి.
pull వెంటనే విఫలమవుతుంది. Error: pull model manifest: file does not exist అంటే ఆ tag library లో లేదని అర్థం. ఇంకా విడుదల కాని version number ను ఉపయోగించినా ఇదే సందేశం వస్తుంది. tag లో ఏదైనా typo ఉన్నా ఇదే జరుగుతుంది. qwen3.8:27b మాత్రం నిజమైన tag. కాబట్టి ఆ ఖచ్చితమైన tag విఫలమైతే ముందుగా typo కోసం చూడండి. మీ network ను నిందించే ముందు library page లో tag ను నిర్ధారించండి. నిజమైన tag pull అయినా run కాకపోతే, ollama --version ను 0.32.12 తో సరిపోల్చి చూడండి.
అన్నీ పనిచేస్తున్నాయి, కానీ వేగం భరించలేనంత తక్కువగా ఉంది. తగినంత RAM ఉన్న system లో సెకనుకు ఒక token కంటే తక్కువ వేగం ఉంటే compute కంటే paging సమస్యను సూచిస్తుంది. generation సమయంలో vmstat 1 అమలు చేయండి. si లేదా so column లో సున్నా కాని విలువ ఉంటే kernel swapping చేస్తోందని అర్థం. context తగ్గించడం లేదా లోడ్ చేసిన models సంఖ్యను తగ్గించడం దీనికి పరిష్కారం. swap activity లేకుండా wa నిరంతరం ఎక్కువగా ఉంటే memory-mapped weights ను disk నుంచి మళ్లీ చదువుతున్నారని అర్థం. అంటే అవి నిజంగా memory లో సరిపోవడం లేదు.
మొదటి token రావడానికి 30 seconds పడుతుంది, తర్వాత output వేగం పెరుగుతుంది. దీనిని prefill అంటారు. ఇది సాధారణమే. cache ను ఉపయోగించలేని ప్రతి request కోసం పొడవైన system prompt ను మళ్లీ process చేయాలి. కాబట్టి మరేదైనా tuning చేయడానికి ముందు system prompt ను కుదించండి.
CPU-only 27B మోడల్ వాస్తవంగా దేనికి ఉపయోగపడుతుంది
ఆశల ఆధారంగా కాకుండా సంఖ్యల ఆధారంగా అంచనాలను నిర్ణయించండి. సెకనుకు రెండు నుంచి నాలుగు tokens వేగంతో, 500 tokens సమాధానానికి రెండు నుంచి నాలుగు నిమిషాలు పడుతుంది. Chat కోసం ఇది ఉపయోగకరం కాదు, కానీ queue కోసం పూర్తిగా సరిపోతుంది. సమాధానం ఇవ్వడానికి ముందు ఆలోచించే మోడల్ ఈ లెక్కను మరింత ప్రతికూలం చేస్తుంది. ఎందుకంటే దాని అంతర్గత reasoning tokens కూడా సమాధానం మాదిరిగానే నెమ్మదిగా generate అవుతాయి. అందువల్ల పని ఆధారంగా reasoning effort స్థాయిని సరిపోల్చడం మోడల్ను మార్చకుండా సమాధానాన్ని త్వరగా పొందడానికి ఉన్న కొద్ది మార్గాల్లో ఒకటి. Document summarisation, bulk tagging, ఫైళ్ల backlog నుంచి field extraction, unattended code review వంటి పనులు ఈ వేగాన్ని తట్టుకుంటాయి, ఎందుకంటే సమాధానం కోసం ఏదీ వేచి ఉండదు. Coding assistance ఈ పరిమితి వద్దే ఉంటుంది. అందువల్ల మీరు host చేసే మోడల్కు coding agent ను అనుసంధానించడం commit messages, test scaffolding వంటి background jobs కు ఉపయోగకరం, కానీ మీరు కూర్చుని వేచి ఉండే inline suggestions కు కాదు.
Privacy వాదనే అసలు కారణం. మోడల్ మీరు rent చేసి నియంత్రించే hardware పై నడుస్తుంది. ఏ request కూడా ఆ యంత్రం వెలుపలికి వెళ్లదు. ప్రతి token కు ప్రత్యేక bill కూడా ఉండదు. సెకనుకు మూడు tokens వేగం ఉన్నా regulated data కోసం ఇది చాలా విలువైనది. అయితే ప్రత్యామ్నాయంతో నిజాయితీగా పోల్చండి: frontier-scale మోడల్ను self-host చేయడానికి క్రమ పరిమాణంలో ఎక్కువ hardware అవసరం, కాబట్టి output ను ఇంకా చదవడం విలువైనదిగా ఉండే ఆ పరిధిలో CPUపై 27B అత్యంత తక్కువ ఖర్చు point.
ఇవన్నీ benchmark చేయడానికి మీకు వాస్తవ structured input అవసరం. చాలా public data APIs throughput ను కొలవడానికి ముందే account కోరుతాయి. Strasmore యొక్క demo schema (దాన్ని మేమే run చేస్తాము) US equities మరియు options data పై read-only SQL ను document చేస్తుంది. దీనికి key లేదా signup అవసరం లేదు. ఇది database-qualified table names ను ఉపయోగిస్తుంది: https://ai.strasmore.com/api/demo/sql?sql=SELECT ticker, close FROM global_markets.delayed_stocks_minute_aggs LIMIT 5. Demo పరిమితులు ఒక్క call కు 500 rows మరియు 20 seconds. ఇందులో 1 January 2025 నుంచి history ఉంది. కాబట్టి సెకనుకు రెండు tokens ఉత్పత్తి చేసే యంత్రం వినియోగించగల పరిమాణం కంటే ఇది సౌకర్యంగా ఎక్కువ. పూర్తి column list https://ai.strasmore.com/api/demo/schema వద్ద ఉంది.
ఇది మీ మొదటి Ollama install అయితే, VPSపై Ollama ను run చేయడానికి పూర్తి walkthrough ఈ guide ముందుగానే ఉన్నాయని భావించే service setup, HTTP API మరియు firewall rules ను వివరిస్తుంది. Port 11434 ను internet కు expose చేయవద్దు. Ollama యొక్క local API కు authentication అవసరం లేదు. కాబట్టి ఆ port ను చేరుకోగల ఎవరైనా మీ మోడల్ను ఉపయోగించవచ్చు.
FAQ
Ollamaలో Qwen 3.8 27B మోడల్ ఉందా?
అవును. 21 October 2026 నాటికి Ollama libraryలో qwen3.8 entry ఉంది. qwen3.8:27b (latestగా కూడా tag చేయబడింది) 27.3 billion parameters కలిగిన dense model యొక్క 18 GB Q4_K_M build. ఇందులో vision projector మరియు 256K context window ఉన్నాయి. ఇది localగా నడుస్తుంది. దీనికి Ollama v0.32.12 లేదా తరువాతి version అవసరం. పాత qwen3.6:27b మరియు qwen3.5:27b tags ఇప్పటికీ జాబితాలో ఉన్నాయి. ప్రస్తుత జాబితా కోసం https://ollama.com/library/qwen3.8/tags చూడండి. లేని tagను ఉపయోగిస్తే Error: pull model manifest: file does not existతో విఫలమవుతుంది.
VPSలో Qwen 27B model నడపడానికి ఎంత RAM అవసరం?
Q4_K_M కోసం 32 GB ఆచరణాత్మక కనిష్ఠం. Weights పరిమాణం 17 GB. vision projector సుమారు 0.9 GB అదనంగా ఉపయోగిస్తుంది. operating systemకు సుమారు 1.5 GB అవసరం. f16లో ప్రతి 16,000 tokens contextకు KV cache సుమారు 1 GB పెరుగుతుంది. Modelలోని 64 layersలో 16 మాత్రమే పెరుగుతున్న cacheను ఉంచుతాయి. 16 GB planలో weights పూర్తిగా సరిపోవు. File memory-mapped కావడం వల్ల swap సహాయం చేయదు; ప్రతి tokenకు kernel దాన్ని disk నుంచి మళ్లీ చదువుతుంది. Q8_0 weights 29 GB ఉన్నప్పటికీ, 64 GBతో పూర్తి 256K windowకు తగిన స్థలం ఉంటుంది.
CPUపై 27B model సెకనుకు ఎన్ని tokens ఇస్తుంది?
మీ memory bandwidthను weights పరిమాణంతో భాగించండి. వచ్చిన విలువలో 50 నుంచి 70 శాతం తీసుకోండి. Two-channel DDR4-3200 VPS ceiling సుమారు 3 tokens per second. వాస్తవ వేగం సుమారు 2 tokens per second ఉంటుంది. Two-channel DDR5-4800 system ceiling సుమారు 4.5. ఇది సుమారు 3 tokens per second అందిస్తుంది. ఎక్కువ channels కలిగిన server platforms కాగితంపై మెరుగ్గా కనిపిస్తాయి. కానీ hostలోని ప్రతి tenantతో memory bandwidth పంచబడుతుంది. అందువల్ల మీ స్వంత వేగాన్ని ollama run qwen3.8:27b --verboseతో కొలిచి, eval rate lineను చదవండి.
CPU-only VPSలో Q4 లేదా Q8 ఉపయోగించాలా?
దాదాపు ప్రతి సందర్భంలో Q4_K_M ఉపయోగించండి. Q8_0 పరిమాణం 29 GB, అయితే Q4_K_M పరిమాణం 17 GB. అందువల్ల Q8_0 weights 32 GBలో సరిపోతాయి. కానీ projector, cache, operating system మరియు runtimeకు తక్కువ headroom మాత్రమే మిగులుతుంది. 64 GBతో దీర్ఘమైన contextకు తగిన స్థలం ఉంటుంది. ప్రతి tokenకు ఇది దాదాపు రెండింతల memoryను తరలిస్తుంది. దాంతో tokens per second సుమారు సగానికి తగ్గుతుంది. 27B modelలో Q4_K_M మరియు Q8_0 మధ్య quality తేడా ఎక్కువ tasksకు స్వల్పమే. RAMను ఎక్కువ context కోసం ఉపయోగించండి. Context పెంచడం వల్ల model చేయగల పనులు మారతాయి; అది సమాధానాల phrasingను మాత్రమే మార్చదు.
పెద్ద RAM VPS కంటే GPU అద్దెకు తీసుకోవడం ఎప్పుడు చౌకగా ఉంటుంది?
మీ duty cycle తక్కువగా ఉన్నప్పుడు లేదా ఒక వ్యక్తి సమాధానం కోసం వేచి ఉన్నప్పుడు. 24 GB memory కలిగిన GPU ఈ weightsపై సిద్ధాంతపరంగా సుమారు 59 tokens per second వరకు అందిస్తుంది. సాధారణ VPSలో అంచనా వేగం 2 లేదా 3 tokens per second మాత్రమే. Instance ఆగినప్పుడు hourly GPU compute charges ఆగిపోతాయి. కానీ persistent storageకు మాత్రం ఖర్చు కొనసాగవచ్చు. 64 GB VPSకు model loadedగా ఉన్నా లేకపోయినా నెలంతా charge వస్తుంది. మీరు రోజుకు వాస్తవంగా ఎన్ని గంటలు tokens generate చేస్తారో లెక్కించండి. Break-even point rental rates, runtime మరియు persistent storage chargesపై ఆధారపడి ఉంటుంది. నిరంతరం నడిచే low-priority batch పనులకు always-on VPS చౌకగా ఉంటుంది.