SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-30

Ollama वर VPS मध्ये Qwen 3.8 27B कसे चालवायचे

Ollama मधील `qwen3.8:27b` साठी 18 GB download, 8 ते 64 GB RAM मध्ये काय बसेल आणि CPU-only VPS वर मिळणारा वेग येथे तपासा.

GPU नसलेल्या VPS वर Qwen 3.8 27B चालवता येईल का?

VPS वर Qwen 3.8 27B चालवण्यासाठी qwen3.8:27b tag आवश्यक आहे. 21 October 2026 रोजी Ollama library मध्ये हा locally 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 ने v0.32.12 मध्ये Qwen 3.8 27B साठी support जोडले. ही आवृत्ती 14 August 2026 रोजी release झाली. त्यामुळे जुनी installation असल्यास आधी upgrade करा. 29 October 2026 रोजी latest stable release v0.40.13 आहे. ती 28 October 2026 रोजी प्रकाशित झाली.

थोडक्यात, 32 GB किंवा त्याहून मोठ्या VPS वर ते चालवता येते, पण वेग कमी असेल. Q4 मधील 27B dense model ला context मधील एकही token साठवण्यापूर्वी, केवळ weights साठी सुमारे 17 GB RAM आवश्यक असते. त्यामुळे 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 arithmetic दोन्हींना लागू होते. कोणतीही command copy करण्यापूर्वी live list तपासा: Ollama qwen3.8 tag page. येथील arithmetic version number वर नव्हे, तर parameter count, प्रति weight bits आणि attention layout वर अवलंबून आहे.

कोणता Ollama tag pull करायचा आणि तो कसा तपासायचा

अस्तित्वात नसलेला tag pull केल्यास स्पष्ट error मिळतो. त्यामुळे सर्व्हरवरच हा निर्णय पटकन घेता येतो. अस्तित्वात असलेला tag स्थानिक पातळीवर चालण्यायोग्य असेलच असे नाही. library मध्ये सूचीबद्ध असलेला, परंतु केवळ Ollama च्या cloud मधून serve होणारा GLM 5.2 वापरताना हीच अडचण येते.

ollama --version
ollama pull qwen3.8:27b
ollama show qwen3.8:27b

ollama show तुमच्याकडे प्रत्यक्षात असलेल्या tag ची architecture, parameter count, context length आणि quantisation दाखवते. Parameter line मध्ये 27.3B आणि quantisation line मध्ये Q4_K_M दिसत असल्यास, या मार्गदर्शकासाठी वापरलेली build तुमच्याकडे आहे. त्याच weights साठी library मध्ये अधिक precision असलेले qwen3.8:27b-q8_0 आणि qwen3.8:27b-bf16, 27b-mtp variants तसेच 27b-nvfp4, 27b-mxfp8, 27b-mlx आणि 27b-mlx-bf16 tags देखील आहेत. Tags page त्यांना MLX असे label करते. हा format Linux VPS ऐवजी Apple Silicon साठी तयार केलेला आहे. qwen3.6 च्या उलट, qwen3.8 entry मध्ये 35b-a3b tags नाहीत. ही MoE (mixture of experts) models अद्याप qwen3.6 अंतर्गत आहेत आणि CPU वर त्यांचे वर्तन खूप वेगळे असते. याबद्दल पुढे अधिक माहिती दिली आहे.

वेटच्या प्रति bit नुसार parameters ची संख्या

तक्ताQwen3.8 27B weights in RAM, by quantisation
या तक्त्यामागील डेटा
[
  {
    "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 मध्ये हे tensors Q6_K वर असल्याचे दिसते: output layer, feed-forward down projections पैकी सुमारे अर्धे, full-attention layers पैकी सुमारे अर्ध्या 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, model च्या बहुतांश भागाप्रमाणे, Q4_K वर राहतात. Format वरील नाव ही सरासरी दर्शवते आणि ही सरासरी सुमारे 5 bits वर येते. Scale च्या दुसऱ्या टोकालाही हाच परिणाम दिसतो: BF16 साठी 55 GB म्हणजे प्रति weight सपाट 16 bits नसून 16.1 bits आहेत. या ठिकाणी token embedding इतर सर्व घटकांप्रमाणे BF16 वर आहे. उरलेला थोडा फरक file metadata, 32-bit वर ठेवलेले normalisation tensors आणि जवळच्या gigabyte पर्यंत round केलेल्या size मुळे येतो.

फक्त language model file साठी नव्हे, तर संपूर्ण tag साठी budget ठेवा. qwen3.8:27b च्या प्रत्येक GGUF tag सोबत सुमारे 0.9 GB चा vision projector देखील येतो. त्यामुळे Q4_K_M tag चा आकार 18 GB दिला आहे.

अधिकृत qwen3.8 library entry मध्ये Q5_K_M साठी published tag नाही. त्यामुळे 19.5 GB ची row मोजलेली नसून, या format साठी नेहमीच्या 5.7 bits per weight वर आधारित आहे. Q8_0 मध्ये Q4 च्या तुलनेत आकार जवळपास दुप्पट होऊन 29 GB होतो. केवळ CPU असलेल्या मशीनवर या दुप्पट आकारामुळे प्रत्येक token साठी memory traffic दुप्पट होते. त्यामुळे प्रति सेकंद तयार होणाऱ्या tokens ची संख्या साधारण अर्धी होते. केवळ या कारणासाठीही Q4_K_M हा येथे योग्य default आहे. या निर्णयाचा memory ऐवजी quality वर होणारा परिणाम पाहायचा असल्यास, Q4, Q8 आणि fp16 यांची अधिक सविस्तर तुलना output ची गुणवत्ता नेमकी कुठे कमी होऊ लागते ते दाखवते.

संदर्भ वाढत असताना KV cache ची किंमत

Weights हा स्थिर खर्च आहे. KV cache (key आणि value cache; मॉडेलने आधी पाहिलेल्या प्रत्येक token साठी ठेवलेली attention state) संदर्भाची लांबी वाढेल तसतसा सरळ प्रमाणात वाढतो. प्रत्यक्षात बहुतेक वेळा RAM संपण्याचे हेच मुख्य कारण असते.

तक्ताKV cache size by context length, Qwen3.8 27B
या तक्त्यामागील डेटा
[
  {
    "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 layers full attention वापरतात आणि प्रत्येक token सोबत वाढणारा cache ठेवतात. या layers मध्ये GQA (grouped-query attention) अंतर्गत 4 key/value heads आणि 256 इतका head dimension आहे. उर्वरित 48 layers linear attention (Gated DeltaNet) वापरतात आणि त्याऐवजी स्थिर आकाराची state ठेवतात. माझ्या गणनेनुसार, संदर्भ कितीही वाढला तरी प्रत्येक conversation slot साठी ही state सुमारे 150 MB असते. त्यामुळे f16 मध्ये प्रत्येक token साठी 64 KiB लागतात. 32k tokens साठी हे 2 GB आणि 128k साठी 8 GB होते. तुमच्या स्वतःच्या box वर ही गणना तशीच लागू होईल असे गृहीत धरू नका. मॉडेल load करा आणि ollama ps मधील SIZE column वाचा. त्यात weights, cache आणि overhead यांची एकत्रित रक्कम दिसते.

Model card मध्ये दिलेला 256K context या architecture वर साध्य आहे, पण तो विनामूल्य मिळत नाही. f16 मध्ये तो पूर्ण भरल्यास weights व्यतिरिक्त सुमारे 16 GB cache लागतो. या मशीनवर weights साठी आधीच 17 GB वापरलेले आहेत. Ollama default म्हणून पूर्ण window देत नाही. त्याच्या 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 ऐवजी 8 bits मध्ये साठवतो. त्यामुळे 32k tokens साठीचा वापर 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 तोच value निश्चित ठेवतो. हे box एकापेक्षा जास्त व्यक्ती वापरणार असतील, तर हीच वाढ समस्या निर्माण करते. self-hosted model एकाच वेळी किती users serve करू शकते हे core count पेक्षा बरेच आधी cache slots आणि queue depth ठरवतात.

8, 16, 32 आणि 64 GB RAM मध्ये काय बसते

तक्ताUsable context by VPS RAM tier, f16 cache, headless Linux
या तक्त्यामागील डेटा
[
  {
    "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 वर किती हजार tokens चा context बसतो हे दर्शवतात. Operating system साठी सुमारे 1.5 GB आणि थोडी अतिरिक्त मोकळी जागा राखून ही गणना केली आहे. शून्याचा अर्थ 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 त्यांना वारंवार evict करून पुन्हा वाचू लागते. त्यानंतर प्रत्येक token साठी disk वरून gigabytes वाचावे लागतात. मशीनमध्ये iowait वाढतो आणि प्रति सेकंद एक token पेक्षाही कमी output मिळतो.

32 GB हा सुरुवातीचा व्यवहार्य स्तर आहे. Weights 17 GB घेतात. vision projector सुमारे 0.9 GB घेतो. त्यामुळे तुमच्याकडे साधारण 12.5 GB उरतात. ही जागा margin ठेवून f16 context चे सुमारे 128k tokens सामावते. 29 GB चे Q8_0 weights 32 GB मध्ये बसतात. पण वापरता येणारा context vision projector, cache, operating system आणि runtime memory यांवरही अवलंबून असतो. या tier वर Q8 चालेल असे गृहीत धरण्यापूर्वी तुमच्या मशीनवरील एकूण memory footprint तपासा.

64 GB मध्ये पुरेशी मोकळी जागा असते. Q4 मुळे पूर्ण 256k window साठी जागा उरते. Q8_0 weights मागे पूर्ण 256k context ठेवूनही बसतात. Q8 साठी 64 GB घेण्यापूर्वी तुम्ही नेमके काय विकत घेत आहात हे स्पष्टपणे समजा: output थोडा चांगला मिळेल, पण वेग निम्मा असेल आणि मशीन आधीपासूनच धीमे असेल. 32 GB plan वर Q4 आधीच 128k tokens पर्यंत पोहोचते. जवळजवळ प्रत्येकासाठी हा अधिक चांगला पर्याय आहे.

VPS वर CPU inference किती वेगाने चालते?

Dense model मधून एक token निर्माण करण्यासाठी प्रत्येक weight एकदा memory मधून वाचावा लागतो. काही weights नव्हे. सर्व weights. त्यामुळे वेगाची मर्यादा तुमच्या core count वर नसते; ती memory bandwidth ला weights च्या आकाराने भागल्यावर मिळणाऱ्या मूल्यावर ठरते. Q4 मध्ये प्रत्येक token साठी memory traffic 17 GB असतो.

तक्ताTheoretical token ceiling from memory bandwidth, 17 GB of weights
या तक्त्यामागील डेटा
[
  {
    "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 मुळे सैद्धांतिक कमाल वेग गाठता येत नाही. दोन-channel DDR4-3200 VPS ची कमाल मर्यादा प्रति सेकंद 3 tokens आहे, त्यामुळे प्रत्यक्षात सुमारे 2 tokens अपेक्षित ठेवा. दोन-channel DDR5-4800 मशीनची कमाल मर्यादा 4.5 आहे, त्यामुळे प्रत्यक्षात सुमारे 3 tokens अपेक्षित ठेवा.

मोठ्या server rows बाबत एक महत्त्वाची सूचना आहे. बारा-channel EPYC platform मध्ये 460.8 GB/s memory bandwidth आणि 27.1 tokens प्रति सेकंदाची कमाल मर्यादा असते; परंतु तुम्ही संपूर्ण EPYC भाड्याने घेत नसता. Memory bandwidth हा त्या मशीनवरील सर्व tenants मध्ये सामायिक केलेला host-wide resource असतो. त्यामुळे 8 vCPU slice सोबत बारा channels ची exclusive bandwidth मिळत नाही. GPU-केंद्रित मार्गदर्शक हा मुद्दा पूर्णपणे वगळतात. त्यामुळेच समान model वर समान vCPU count असलेल्या दोन VPS plans च्या कामगिरीत तीनपट फरक असू शकतो.

याच कारणामुळे अधिक vCPUs लवकरच उपयोगी पडेनासे होतात. Cores memory controller पुरवू शकतो त्यापेक्षा वेगाने data मागू लागल्यावर अतिरिक्त threads मुळे scheduling overhead वाढतो; इतर कोणताही फायदा होत नाही. Ollama मध्ये thread count साठी server-wide environment variable नाही. त्यामुळे request मधील num_thread मध्ये options वापरून तो तुमच्या physical core count इतका सेट करा, मोजमाप घ्या आणि नंतर त्याच्या निम्म्या संख्येचा प्रयत्न करा. अनेक shared plans वर कमी setting अधिक वेगवान असते.

Prompt processing वेगळ्या प्रकारे चालते. Prefill म्हणजे पहिला token दिसण्यापूर्वी input वर चालणारा pass. तो bandwidth bound नसून compute bound असतो, त्यामुळे cores वाढवल्यावर त्याचा वेग वाढतो. प्रत्यक्षात मोठ्या prompt साठी output सुरू होण्यापूर्वी मोठा विलंब होतो आणि त्यानंतर वर सांगितलेला स्थिर, कमी दर मिळतो. --verbose वापरून दोन्ही टप्प्यांचा वेळ स्वतंत्रपणे मोजा. प्रत्येक request साठी ते एक prompt eval rate आणि एक eval rate दाखवते.

Dense 27B model खूपच धीमा असल्यास CPU सोडण्यापूर्वी qwen3.6:35b-a3b tags तपासा. हे सर्व 27.3 billion parameters ऐवजी प्रत्येक token साठी साधारण 3 billion parameters सक्रिय करतात. त्यामुळे disk वरील file मोठी असली तरी प्रत्येक token साठीचा memory traffic जवळपास एका order of magnitude ने कमी होतो. तुम्ही RAM footprint च्या बदल्यात वेग मिळवता. येथे runtime ची निवडही महत्त्वाची आहे. समान underlying inference code वर Ollama आणि llama.cpp वेगवेगळी CPU tuning controls उपलब्ध करतात.

GPU तास भाड्याने घेणे कधी अधिक योग्य ठरते

तक्ताGPU memory bandwidth and token ceiling on the same 17 GB of weights
या तक्त्यामागील डेटा
[
  {
    "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 per second इतका असतो. सध्याचे data centre card 197 पर्यंत पोहोचते. Thread counts समायोजित करून ही तफावत भरून काढता येत नाही. तुमच्या VPS वर memory bandwidth काही tens इतकी असताना, card आपली memory 1008 GB/s वेगाने चालवते.

म्हणून निर्णय आवडीनुसार नव्हे, तर workload नुसार घ्या. काम asynchronous असेल आणि त्याच्या परिणामाची कोणी वाट पाहत नसेल, तर CPU inference योग्य पर्याय आहे: दस्तऐवजांच्या मोठ्या संचाचे overnight summarisation किंवा तुम्ही झोपलेले असताना चालणारे nightly classification job. एखादी व्यक्ती output ची वाट पाहत असेल किंवा तुमच्या box ला requests पूर्ण करण्यापेक्षा त्या जलद येत असतील, तर GPU भाड्याने घ्या. CPU runtimes एकावेळी फक्त एकाच request पुरते मर्यादित नसतात: llama.cpp server मध्ये CPU तसेच GPU वर parallel decoding आणि continuous batching यांचे documentation आहे. Ollama देखील parallel requests serve करू शकते; मात्र यासाठी अधिक cache लागतो. तुमचा measured serving rate आणि arrival rate यांची तुलना निर्णायक ठरते. त्यामुळे तुमच्या स्वतःच्या box वर वास्तववादी batch चा कालावधी मोजा. Requests त्या वेगापेक्षा जलद येऊ लागल्यावर queue वाढते.

खर्चाची तुलना दिसते तितकी सरळ नाही. Model loaded असो वा नसो, 64 GB VPS साठी संपूर्ण महिन्यातील प्रत्येक तासाचे billing होते. याउलट, hourly GPU rental मध्ये compute charges आणि storage charges वेगळे असतात; GPU थांबल्यानंतरही storage charges सुरू राहू शकतात. तुमचा प्रत्यक्ष वापर दररोज दोन तासांचा असेल, तर rented GPU अधिक जलद आणि स्वस्त दोन्ही ठरू शकतो. आधी तुमचा duty cycle काढा आणि नंतर किंमत मोजा. GPU असलेला VPS निवडताना काय तपासावे मध्ये instance वर तपासायच्या बाबी दिल्या आहेत. GPU वर concurrent requests serve केल्यावर योग्य batching मुळे concurrent requests serve करताना vLLM Ollama पेक्षा पुढे का जाते हे स्पष्ट होते.

लोक अनेकदा विसरतात असा तिसरा पर्यायही आहे. Batch work साठी 27B CPU वर ठेवा आणि interactive path साठी त्यापुढे hosted API model वापरा. एकाच model ने दोन्ही कामे serve करणे आवश्यक नाही.

Ollama स्थापित करा आणि आपल्या मशीनची मोजणी करा

ही install script अधिकृत आहे. ती स्वतंत्र ollama user म्हणून चालणारी systemd service तयार करते.

curl -fsSL https://ollama.com/install.sh | sh
ollama --version
free -g

ollama --version मध्ये 0.32.12 किंवा त्यानंतरची आवृत्ती दिसली पाहिजे. Qwen 3.8 27B साठी support असलेली ही पहिली release आहे. काहीही pull करण्यापूर्वी free -g तपासा. त्यात GiB दाखवले जाते. त्यामुळे 32 GB RAM असलेल्या योजनेत 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 ही तुम्हाला हवी असलेली मोजणी आहे. Generation दरम्यानचा तुमचा tokens per second म्हणजे eval rate. Prefill speed म्हणजे prompt eval rate. Disk वरून weights वाचण्यासाठी लागलेला वेळ म्हणजे load duration. म्हणूनच OLLAMA_KEEP_ALIVE=60m सेट केले आहे: CPU वर प्रत्येक request वेळी disk वरून 17 GB पुन्हा load करण्याचा खर्च request पेक्षाही जास्त असतो. Default idle timeout पाच मिनिटे आहे. Items मधे अंतर असलेल्या batch queue ला हा load cost पुन्हा पुन्हा द्यावा लागू शकतो. model resident ठेवण्याचे पर्याय प्रति-request keep_alive field आणि reboot नंतरही setting कायम ठेवणे, दोन्ही समाविष्ट करतात.

Model loaded असताना दुसऱ्या terminal मधून memory footprint तपासा.

ollama ps

SIZE 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 वर दुसऱ्या component ने claim केले आहे. अशा वेळी या मार्गदर्शकातील speed numbers तुमच्या मशीनला लागू होत नाहीत.

अपयशाच्या स्थिती आणि दिसणारे अचूक strings

Model load होत नाही. Ollama दोन्ही आकडे असलेली ओळ model requires more system memory (18.6 GiB) than is available (15.2 GiB) या स्वरूपात दाखवते. हे चांगले अपयश आहे, कारण kernel ला निर्णय घेऊ देण्याऐवजी Ollama memory allocate करण्यापूर्वी तपासणी करते. Context length कमी करा, लहान tag वापरा किंवा मोठ्या plan वर जा.

उत्तराच्या मध्यात process अदृश्य होते. Client उपयुक्त माहिती दाखवत नाही आणि journalctl -u ollama -n 50 मध्ये service पुन्हा सुरू होत असल्याचे दिसते. dmesg -T | tail चालवा. त्यात Out of memory: Killed process ... (ollama) अशी ओळ असल्यास kernel OOM killer ने process बंद केली आहे. Pre-load तपासणी यशस्वी झाली होती, पण दीर्घ conversation दरम्यान cache अंदाजापेक्षा मोठा झाला, तेव्हा असे होते. Context length कमी करा.

Pull लगेच अपयशी ठरतो. Error: pull model manifest: file does not exist याचा अर्थ tag library मध्ये उपलब्ध नाही. Release न केलेला version number दिल्यास आणि tag मध्ये typo असल्यासही हेच दिसते. qwen3.8:27b स्वतः वैध आहे. त्यामुळे तोच 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 मधील non-zero value म्हणजे kernel swapping करत आहे. Context कमी करणे किंवा loaded models ची संख्या कमी करणे हा उपाय आहे. Swap activity नसताना wa सतत जास्त असल्यास memory-mapped weights disk वरून पुन्हा वाचले जात आहेत. याचा अर्थ ते प्रत्यक्षात memory मध्ये बसत नाहीत.

पहिल्या token साठी 30 seconds लागतात आणि त्यानंतर output वेगवान होते. ही prefill प्रक्रिया आहे आणि ती सामान्य आहे. Cache hit न होणाऱ्या प्रत्येक request साठी लांब system prompt ची किंमत पुन्हा मोजावी लागते. त्यामुळे इतर कोणतेही tuning करण्यापूर्वी system prompt लहान करा.

CPU-only 27B प्रत्यक्षात कशासाठी उपयुक्त आहे

आशेऐवजी आकडे पाहून अपेक्षा ठरवा. प्रति सेकंद दोन ते चार tokens या गतीने 500 tokens चे उत्तर देण्यासाठी दोन ते चार मिनिटे लागतात. Chat साठी हा वेग अनुपयोगी आहे; queue साठी मात्र तो व्यवस्थित चालतो. उत्तर देण्यापूर्वी विचार करणारे model ही गणना आणखी प्रतिकूल करते, कारण लपवलेले reasoning tokens उत्तराइतक्याच कमी गतीने तयार होतात. त्यामुळे कामानुसार reasoning effort level जुळवणे हे model बदलल्याशिवाय उत्तराचा वेळ कमी करणाऱ्या मोजक्या उपायांपैकी एक आहे. Document summarisation, bulk tagging, files च्या backlog मधून field extraction आणि unattended code review ही कामे हा विलंब सहन करतात, कारण उत्तराची वाट पाहणारा वापरकर्ता नसतो. Coding assistance या मर्यादेवरच येते. त्यामुळे तुम्ही host केलेल्या model कडे coding agent निर्देशित करणे commit messages आणि test scaffolding यांसारख्या background jobs साठी उपयुक्त ठरते; मात्र तुम्ही बसून वाट पाहता त्या inline suggestions साठी ते योग्य नाही.

Privacy हा खरा मुद्दा आहे. Model तुम्ही भाड्याने घेतलेल्या आणि नियंत्रित केलेल्या hardware वर चालते. कोणतीही request त्या box च्या बाहेर जात नाही आणि प्रति-token शुल्कही नसते. प्रति सेकंद तीन tokens एवढीच गती असली तरी regulated data साठी याचे मूल्य मोठे आहे. हा पर्याय प्रामाणिकपणे दुसऱ्या पर्यायाशी तुलना करा: frontier-scale model self-host करण्यासाठी त्यापेक्षा एका order of magnitude ने अधिक hardware लागते. त्यामुळे output वाचण्यासारखे राहते अशा त्या hardware curve वरील सर्वात स्वस्त बिंदूंपैकी CPU वर चालणारे 27B हे एक आहे.

यापैकी कोणत्याही बाबीचे benchmark करण्यासाठी तुम्हाला प्रत्यक्ष structured input आवश्यक आहे. बहुतेक public data APIs throughput मोजण्यापूर्वी account मागतात. Strasmore चा demo schema (तो आम्ही चालवतो) US equities आणि options data वर read-only SQL चे documentation देतो. त्यासाठी 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 प्रक्रिया करणारा boxही त्यातील सर्व data सहज वापरू शकतो. पूर्ण column list येथे आहे: https://ai.strasmore.com/api/demo/schema.

ही तुमची पहिली Ollama install असल्यास, VPS वर Ollama चालवण्यासाठीचे संपूर्ण walkthrough service setup, HTTP API आणि या मार्गदर्शकात गृहीत धरलेले firewall rules समजावते. Port 11434 इंटरनेटवर expose करू नका. Ollama च्या local API साठी authentication आवश्यक नाही. त्यामुळे त्या port पर्यंत पोहोचणारी कोणतीही व्यक्ती तुमचे model वापरू शकते.

FAQ

Ollama वर Qwen 3.8 27B मॉडेल आहे का?

होय. 21 October 2026 रोजी Ollama library मध्ये qwen3.8 entry उपलब्ध आहे. qwen3.8:27b (latest असेही tag केलेले) हे vision projector आणि 256K context window असलेले 27.3 billion parameter dense model चे 18 GB Q4_K_M build आहे. ते स्थानिक पातळीवर चालते आणि Ollama v0.32.12 किंवा त्यानंतरची आवृत्ती आवश्यक आहे. जुने 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 मॉडेल चालवण्यासाठी किती RAM आवश्यक आहे?

Q4_K_M साठी 32 GB ही व्यावहारिक किमान क्षमता आहे. Weights साठी 17 GB आवश्यक आहेत. Vision projector सुमारे 0.9 GB अतिरिक्त जागा घेतो. Operating system ला सुमारे 1.5 GB आवश्यक असतात. f16 मध्ये context च्या प्रत्येक 16,000 tokens साठी KV cache सुमारे 1 GB वाढतो, कारण मॉडेलच्या 64 layers पैकी फक्त 16 layers वाढणारा cache ठेवतात. 16 GB plan मध्ये weights मावणारच नाहीत. File memory-mapped असल्यामुळे swap उपयोगी ठरत नाही; kernel प्रत्येक token वेळी ती disk वरून पुन्हा वाचतो. 29 GB Q8_0 weights वापरूनही 64 GB मध्ये पूर्ण 256K window साठी पुरेशी जागा मिळते.

CPU वर 27B मॉडेल किती tokens per second देईल?

तुमची memory bandwidth weights च्या आकाराने भागा आणि त्याच्या 50 ते 70 टक्के क्षमतेचा अंदाज घ्या. दोन-channel DDR4-3200 VPS ची कमाल मर्यादा सुमारे 3 tokens per second असते आणि प्रत्यक्ष वेग सुमारे 2 असतो. दोन-channel DDR5-4800 मशीनची कमाल मर्यादा सुमारे 4.5 असते आणि प्रत्यक्ष वेग सुमारे 3 असतो. अधिक channels असलेले server platforms कागदावर खूप चांगले दिसतात. मात्र host वरील प्रत्येक tenant मध्ये memory bandwidth वाटली जाते. त्यामुळे ollama run qwen3.8:27b --verbose वापरून स्वतःच्या सिस्टमवर मोजमाप करा आणि eval rate line वाचा.

फक्त CPU असलेल्या 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 साठी Q8_0 जवळजवळ दुप्पट memory हलवते, त्यामुळे tokens per second साधारण निम्मे होतात. 27B मॉडेलवर Q4_K_M आणि Q8_0 यांतील quality difference बहुतेक कामांसाठी कमी असतो. अधिक RAM लांब context साठी वापरा. त्यामुळे मॉडेल वाक्यरचना कशी करते यापेक्षा ते काय करू शकते यात अधिक फरक पडतो.

मोठ्या RAM असलेल्या VPS पेक्षा GPU भाड्याने घेणे कधी स्वस्त ठरते?

तुमचा duty cycle कमी असेल किंवा एखादी व्यक्ती output ची वाट पाहत असेल तेव्हा. 24 GB memory असलेल्या GPU ची या weights वर सैद्धांतिक कमाल गती सुमारे 59 tokens per second असते. याच्या तुलनेत सामान्य VPS वर अंदाजे 2 किंवा 3 tokens per second मिळतात. Instance बंद केल्यावर hourly GPU compute charges थांबतात. मात्र persistent storage साठी खर्च सुरू राहू शकतो. मॉडेल loaded असो किंवा नसो, 64 GB VPS साठी संपूर्ण महिन्याचे billing होते. तुम्ही प्रत्यक्षात दररोज किती तास tokens generate करता ते मोजा. Break-even point rental rates, runtime आणि persistent storage charges यांवर अवलंबून असतो. सतत चालणारे low-priority batch काम असल्यास always-on VPS अधिक फायदेशीर ठरतो.

हा लेख उपयुक्त होता का?