SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-30

VPS-ல் Ollama மூலம் Qwen 3.8 27B இயக்குவது எப்படி

`qwen3.8:27b` இயக்க Ollama v0.32.12 அல்லது அதற்குப் பிந்தைய பதிப்பு தேவை. CPU-only VPS-ல் 8, 16, 32 முதல் 64 GB வரை RAM மற்றும் வேகக் கணக்கை அறியுங்கள்.

GPU இல்லாத VPS-ல் Qwen 3.8 27B-ஐ இயக்க முடியுமா?

VPS-ல் Qwen 3.8 27B-ஐ இயக்க, qwen3.8:27b tag தேவை. 21 October 2026 நிலவரப்படி, Ollama library-ல் இதை local-ஆக 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, Qwen 3.8 27B support-ஐ 14 August 2026 அன்று வெளியிடப்பட்ட v0.32.12-ல் சேர்த்தது. எனவே பழைய install இருந்தால் முதலில் upgrade செய்ய வேண்டும். 29 October 2026 நிலவரப்படி, latest stable release v0.40.13 ஆகும்; இது 28 October 2026 அன்று வெளியிடப்பட்டது.

சுருக்கமான பதில்: 32 GB அல்லது அதற்கு மேற்பட்ட VPS-ல் இயக்கலாம்; ஆனால் வேகம் குறைவாக இருக்கும். Q4-ல் உள்ள 27B dense model-க்கு weights மட்டும் சேமிக்க சுமார் 17 GB RAM தேவைப்படும். ஒரு token context சேமிக்கப்படுவதற்கு முன்பே இந்த அளவு தேவைப்படுகிறது. எனவே 8 GB மற்றும் 16 GB plans முற்றிலும் பொருந்தாது. பொதுவான dual-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 செய்ய முயன்றால் தெளிவான பிழைச் செய்தி கிடைக்கும், எனவே server-ல் இதை விரைவாக உறுதிப்படுத்தலாம். ஏற்கனவே உள்ள ஒரு tag-கூட local-ல் இயங்காமல் போகலாம்; இதுதான் GLM 5.2, library-ல் பட்டியலிடப்பட்டிருந்தாலும் Ollama cloud-லிருந்து மட்டுமே வழங்கப்படுவது போன்ற சூழல்களில் பயனர்களுக்குச் சிக்கலை ஏற்படுத்துகிறது.

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

ollama show கட்டளையானது உங்களிடம் உள்ள tag-க்கான architecture, parameter எண்ணிக்கை, context length மற்றும் quantisation ஆகியவற்றைத் திரையில் காட்டும். parameter வரிசையில் 27.3B என்றும், quantisation வரிசையில் Q4_K_M என்றும் இருந்தால், இந்த வழிகாட்டியில் பயன்படுத்தப்பட்டுள்ள அதே build உங்களிடம் உள்ளது என்று அர்த்தம். இந்த library-ல் அதே weights-க்கு அதிக precision கொண்ட qwen3.8:27b-q8_0 மற்றும் qwen3.8:27b-bf16, 27b-mtp variants, மற்றும் 27b-nvfp4, 27b-mxfp8, 27b-mlx, 27b-mlx-bf16 ஆகிய tag-களும் உள்ளன; இவை Linux VPS-க்கு பதிலாக Apple Silicon-க்காக உருவாக்கப்பட்ட MLX format-ஐச் சேர்ந்தவை. qwen3.6 போலன்றி, qwen3.8 உள்ளீட்டில் 35b-a3b tag-கள் இல்லை. அந்த MoE (mixture of experts) மாதிரிகள் இன்னும் qwen3.6-ன் கீழ் உள்ளன மற்றும் CPU-ல் அவை முற்றிலும் மாறுபட்ட முறையில் செயல்படும். இதைப் பற்றிய கூடுதல் விவரங்கள் கீழே கொடுக்கப்பட்டுள்ளன.

Parameter count times bytes per weight

விளக்கப்படம்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"
  }
]

இந்த formula ஒரு வரியில் உள்ளது. Weights-ன் bytes = parameters * bits per weight / 8. சரியாக 4 bits என்றால், 27.3 billion parameters-க்கு 13.7 GB தேவைப்படும். Shipped Q4_K_M tag-ல் உள்ள language model file அளவு 17 GB. நடைமுறையில் இது ஒரு weight-க்கு 4.98 bits ஆகும்.

இந்த வேறுபாடு பிழையல்ல. K-quant formats ஒவ்வொரு tensor-ஐயும் nominal width-ல் சேமிப்பதில்லை. Compression காரணமாக quality அதிகமாகக் குறையும் tensors-க்கு அதிக bits வழங்கப்படும். Shipped qwen3.8:27b file-க்கான Ollama tensor listing-ல் இவை Q6_K-ல் உள்ளன: output layer, feed-forward down projections-ல் சுமார் பாதி, முழுமையான 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 ஆகியவை model-ன் பெரும்பகுதியைப் போலவே Q4_K-ல் தொடர்கின்றன. Format-ன் பெயர் ஒரு average-ஐக் குறிக்கிறது; அந்த average சுமார் 5 ஆகும். இதே விளைவு scale-ன் மறுபுறத்திலும் காணப்படுகிறது: BF16-க்கான 55 GB என்பது ஒரு weight-க்கு flat 16 bits அல்ல; 16.1 bits ஆகும். அங்கு token embedding உட்பட அனைத்தும் BF16-ல் உள்ளன. சிறிய கூடுதல் அளவு file metadata, 32-bit-ல் வைத்திருக்கும் normalisation tensors, மற்றும் nearest gigabyte-க்கு round செய்யப்பட்ட listed size ஆகியவற்றால் ஏற்படுகிறது.

Language model file-ஐ மட்டும் கணக்கிடாமல், முழு tag-க்கான memory-ஐ budget செய்யவும். qwen3.8:27b-ன் ஒவ்வொரு GGUF tag-உம் சுமார் 0.9 GB அளவுள்ள vision projector-ஐக் கொண்டுள்ளது. அதனால்தான் Q4_K_M tag 18 GB எனக் குறிப்பிடப்பட்டுள்ளது.

Official 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-only box-ல் இந்த இரட்டிப்பு ஒவ்வொரு token-க்கும் memory traffic-ஐ இருமடங்காக்கும். இதனால் tokens per second-மும் சுமார் பாதியாகும். இந்த காரணத்திற்காக மட்டும் Q4_K_M இங்கு சரியான default ஆகும். Memory அளவை விட quality தொடர்பான முடிவை அறிய விரும்பினால், Q4, Q8 மற்றும் fp16 பற்றிய விரிவான ஒப்பீடு output உண்மையில் எந்த நிலையில் quality இழக்கத் தொடங்குகிறது என்பதை காட்டுகிறது.

Context வளரும்போது KV cache-ன் செலவு

Model weights என்பது நிலையான செலவு. KV cache (key and value cache, இது model இதுவரை பார்த்த ஒவ்வொரு token-க்கும் பராமரிக்கும் attention state) context நீளத்திற்கு ஏற்ப நேர்க்கோட்டில் வளரும்; பெரும்பாலான பயனர்களுக்கு 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
  }
]

இந்த அளவீடுகள் model-ன் சொந்த 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-ஐப் பராமரிக்கின்றன. எனது கணக்கீட்டின்படி, context எவ்வளவு நீளமாக இருந்தாலும், ஒரு conversation slot-க்கு இது சுமார் 150 MB ஆகும். f16-ல் இது ஒரு token-க்கு 64 KiB என கணக்கிடப்படுகிறது, எனவே 32k tokens-க்கு 2 GB மற்றும் 128k tokens-க்கு 8 GB தேவைப்படும். எனது கணக்கீட்டை மட்டும் நம்பாமல், உங்கள் கணினியில் சரிபார்க்கவும். Model-ஐ load செய்து ollama ps-ன் SIZE column-ஐப் பார்க்கவும்; இது weights, cache மற்றும் overhead ஆகியவற்றை உள்ளடக்கிய மொத்த அளவைக் காட்டும்.

Model card-ல் குறிப்பிடப்பட்டுள்ள 256K context இந்த architecture-ல் சாத்தியம், ஆனால் அதற்குச் செலவு உண்டு. f16-ல் இதை முழுமையாக நிரப்ப, weights-க்கு மேல் சுமார் 16 GB cache தேவைப்படும்; ஏற்கனவே weights-க்காக 17 GB செலவழிக்கும் கணினியில் இது கூடுதல் சுமை. Ollama இயல்பாகவே முழு window-ஐ உங்களுக்குத் தராது. அதன் context-length ஆவணங்கள் VRAM-ஐ அடிப்படையாகக் கொண்டு default-ஐ நிர்ணயிக்கின்றன: 24 GiB-க்குக் கீழ் 4k tokens, 24 முதல் 48 GiB வரை 32k, மற்றும் 48 GiB அல்லது அதற்கு மேல் 256k. CPU-மட்டும் கொண்ட VPS-ல் VRAM இல்லாததால், அது 4k tier-ல் அமையும்; நீங்கள் OLLAMA_CONTEXT_LENGTH மூலம் இதைத் திட்டமிட்டு உயர்த்த வேண்டும். அந்த server-wide variable மட்டுமே ஒரே வழி அல்ல; individual request-ல் num_ctx-ஐ அமைப்பதன் மூலம், மற்றவற்றுக்குக் குறைந்த default-ஐ வைத்துக்கொண்டு, ஒரு நீண்ட பணிக்கு மட்டும் பெரிய window-ஐப் பெற முடியும். ஒவ்வொரு மாற்றத்திற்குப் பிறகும் ollama ps-ஐச் சரிபார்த்து, படிப்படியாக உயர்த்தவும்.

இரண்டு அமைப்புகள் cache-ஐக் குறைக்க உதவுகின்றன. 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 ஒரே நேரத்தில் பல request-களைக் கையாள முடியும், ஒவ்வொரு slot-க்கும் தனித்தனி context பகுதி ஒதுக்கப்படும். எனவே, parallelism-ஐ அதிகரிப்பது நீங்கள் திட்டமிட்ட cache அளவை மடங்காகப் பெருக்கும். தற்போதைய default 1 ஆக உள்ளது, கீழே உள்ள override அதை அப்படியே நிலைநிறுத்துகிறது. ஒன்றுக்கும் மேற்பட்ட பயனர்கள் இந்த server-ஐப் பயன்படுத்தினால், அந்தப் பெருக்கமே சிக்கலை உருவாக்கும். Self-hosted model-ஐ ஒரே நேரத்தில் எத்தனை பயனர்கள் பயன்படுத்தலாம் என்பது 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-ல், operating system-க்கு சுமார் 1.5 GB மற்றும் சிறிய கூடுதல் memory margin மீதமிருக்கும் நிலையில், பொருந்தக்கூடிய context அளவை ஆயிரம் tokens-ஆகக் காட்டும் இரண்டு எண்களாக இதைப் படிக்கவும். 0 என்றால் 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 அளவு data படிக்கப்படும். அந்த machine-ல் iowait அதிகமாக இருக்கும்; output வேகம் ஒரு second-க்கு ஒரு token-க்கும் குறைவாக இருக்கும்.

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 இயங்கும் என்று கருதுவதற்கு முன், உங்கள் machine-ல் மொத்த memory footprint-ஐச் சரிபார்க்கவும்.

64 GB வசதியான அளவு. Q4, முழு 256k window-க்கு இடமளிக்கும். Q8_0 weights-உம் அவற்றுக்குப் பின்னால் முழு 256k context-ஐக் கையாளும் அளவுக்கு பொருந்தும். Q8 பெறுவதற்காக 64 GB RAM-க்கு பணம் செலுத்துவதற்கு முன், நீங்கள் எதை வாங்குகிறீர்கள் என்பதைத் தெளிவாகப் புரிந்துகொள்ளுங்கள்: ஏற்கனவே மெதுவாக இருந்த machine-ல், பாதி வேகத்தில் சற்றே சிறந்த output. 32 GB plan-லேயே Q4, 128k tokens வரை கையாளும். கிட்டத்தட்ட அனைவருக்கும் அது சிறந்த சமநிலை.

VPS-ல் CPU inference எவ்வளவு வேகமாக இருக்கும்?

ஒரு dense model-லிருந்து ஒரு token-ஐ உருவாக்குவது என்பது, அதன் ஒவ்வொரு weight-ஐயும் நினைவகத்திலிருந்து (memory) ஒருமுறை வாசிப்பதாகும். சிலவற்றை மட்டும் அல்ல, அனைத்தையும். எனவே, வேகத்திற்கான வரம்பு உங்கள் CPU core-களின் எண்ணிக்கை அல்ல; அது நினைவகத்தின் அலைவரிசையை (memory bandwidth) weights-ன் அளவால் வகுக்கும்போது கிடைக்கும் மதிப்பாகும். Q4 குவாண்டலைசேஷனில், ஒரு token-க்கு 17 GB நினைவகப் போக்குவரத்து (memory traffic) தேவைப்படும்.

விளக்கப்படம்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
  }
]

இவை வெறும் உச்சவரம்புகள் (ceilings), அளவீடுகள் அல்ல. நினைவகத்தின் தாமதம் (latency) மற்றும் முழுமையற்ற prefetching காரணமாக, கோட்பாட்டு ரீதியான உச்சத்தை எட்ட முடியாது என்பதால், உண்மையான வெளியீடு காட்டப்பட்டுள்ள மதிப்பில் சுமார் 50 முதல் 70 சதவீதம் மட்டுமே இருக்கும். இரண்டு சேனல் கொண்ட DDR4-3200 VPS-ன் உச்சவரம்பு வினாடிக்கு 3 tokens ஆகும், எனவே சுமார் 2 tokens-ஐ எதிர்பார்க்கலாம். இரண்டு சேனல் கொண்ட DDR5-4800 வசதி கொண்ட கணினியின் உச்சவரம்பு 4.5 ஆகும், எனவே சுமார் 3 tokens-ஐ எதிர்பார்க்கலாம்.

பெரிய server-களைப் பயன்படுத்தும்போது எச்சரிக்கையாக இருக்க வேண்டும். பன்னிரண்டு சேனல் கொண்ட EPYC தளத்தில் 460.8 GB/s அலைவரிசையும், வினாடிக்கு 27.1 tokens உச்சவரம்பும் உள்ளது. ஆனால், நீங்கள் முழு EPYC-ஐயும் வாடகைக்கு எடுப்பதில்லை. நினைவக அலைவரிசை என்பது அந்த இயந்திரத்தில் உள்ள அனைத்து வாடிக்கையாளர்களும் பகிர்ந்து கொள்ளும் ஒரு பொதுவான வளமாகும். எனவே, 8 vCPU கொண்ட ஒரு slice-க்கு பன்னிரண்டு சேனல்களின் பிரத்யேக அலைவரிசை கிடைக்காது. GPU-ஐ மையமாகக் கொண்ட வழிகாட்டிகள் இதை முற்றிலும் தவிர்த்துவிடுகின்றன. ஒரே மாதிரியான vCPU எண்ணிக்கை கொண்ட இரண்டு VPS திட்டங்கள், ஒரே மாதிரியான model-ல் மூன்று மடங்கு வேக வித்தியாசத்தைக் காட்டுவதற்கு இதுவே காரணம்.

இதே காரணத்திற்காக, அதிக vCPU-களைப் பயன்படுத்துவது ஒரு கட்டத்திற்கு மேல் பலன் தராது. நினைவகக் கட்டுப்படுத்தி (memory controller) தரவை வழங்கும் வேகத்தை விட, core-கள் தரவைக் கோரும் வேகம் அதிகமாகிவிட்டால், கூடுதல் threads-களைச் சேர்ப்பது scheduling overhead-ஐ மட்டுமே அதிகரிக்கும். Ollama-வில் thread எண்ணிக்கையை நிர்ணயிக்க server-wide environment variable கிடையாது. எனவே, num_thread-ஐ உங்கள் physical core எண்ணிக்கைக்கு ஏற்ப request options-ல் அமைத்துச் சோதிக்கவும். பிறகு, அந்த எண்ணிக்கையில் பாதியை அமைத்துச் சோதிக்கவும். பல shared திட்டங்களில், குறைந்த எண்ணிக்கையிலான அமைப்பே வேகமானது.

Prompt processing மாறுபட்ட முறையில் செயல்படுகிறது. முதல் token தோன்றுவதற்கு முன்பு உள்ளீட்டைச் செயலாக்கும் Prefill, அலைவரிசையை விட கணக்கீட்டுத் திறனை (compute) அதிகம் சார்ந்தது. எனவே, இது core-களின் எண்ணிக்கைக்கு ஏற்ப அதிகரிக்கும். இதன் நடைமுறை விளைவு என்னவென்றால், பெரிய prompt-களுக்கு வெளியீடு தொடங்குவதற்கு முன் நீண்ட இடைவெளி இருக்கும், அதைத் தொடர்ந்து மேலே குறிப்பிட்ட மெதுவான, சீரான வேகம் இருக்கும். --verbose-ஐப் பயன்படுத்தி இந்த இரண்டு பகுதிகளையும் தனித்தனியாகக் கணக்கிடுங்கள்; இது ஒவ்வொரு request-க்கும் prompt eval rate மற்றும் eval rate-ஐ அச்சிடும்.

dense 27B model மிகவும் மெதுவாக இருந்தால், CPU-ஐக் கைவிடுவதற்கு முன் qwen3.6:35b-a3b tags-ஐப் பார்க்கவும். இவை 27.3 பில்லியன் parameters-க்கு பதிலாக, ஒரு token-க்கு சுமார் 3 பில்லியன் parameters-ஐ மட்டுமே செயல்படுத்துகின்றன. இதனால், disk-ல் உள்ள கோப்பு பெரியதாக இருந்தாலும், ஒரு token-க்கான நினைவகப் போக்குவரத்து கணிசமாகக் குறைகிறது. நீங்கள் RAM பயன்பாட்டைக் கொடுத்து வேகத்தைப் பெறுகிறீர்கள். Runtime தேர்வு இங்கு முக்கியமானது, மேலும் Ollama மற்றும் llama.cpp ஆகியவை ஒரே அடிப்படை inference code-க்கு வெவ்வேறு CPU tuning கட்டுப்பாடுகளை வழங்குகின்றன.

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-க்கு இதே formula-வைப் பயன்படுத்தினால், வேறுபட்ட வகை முடிவு கிடைக்கும். 24 GB consumer card-க்கு, இந்த weights மீது அதிகபட்சம் ஒரு வினாடிக்கு 59 tokens வரை மட்டுமே செயலாக்க முடியும். தற்போதைய data centre card ஒன்று 197 tokens வரை செயலாக்கும். Thread counts-ஐ tuning செய்வதால் இந்த இடைவெளியை நிரப்ப முடியாது. உங்கள் VPS-ல் memory bandwidth சில பத்து GB/s அளவில் இருக்கும்; அந்த card தனது memory-ஐ 1008 GB/s வேகத்தில் இயக்குகிறது.

எனவே, உங்கள் விருப்பத்தை அடிப்படையாகக் கொள்ளாமல் workload-ஐ அடிப்படையாகக் கொண்டு முடிவு செய்யுங்கள். வேலை asynchronous-ஆக இருந்து, யாரும் அதன் முடிவுக்காகக் காத்திருக்கவில்லை என்றால் CPU inference சரியான தேர்வு. உதாரணமாக, ஆவணங்களின் தொகுப்பை இரவு நேரத்தில் summarise செய்வது அல்லது நீங்கள் தூங்கும்போது 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 பெரிதாகும்.

Cost comparison வெளிப்படையாகத் தோன்றுவது போல எளிதானதல்ல. Model loaded நிலையில் இல்லாவிட்டாலும், 64 GB VPS மாதத்தின் ஒவ்வொரு மணி நேரத்திற்கும் கட்டணம் வசூலிக்கும். ஆனால் hourly GPU rental-ல் compute charges மற்றும் storage charges தனித்தனியாக இருக்கும்; GPU நிறுத்தப்பட்ட பிறகும் storage charge தொடரலாம். உங்கள் உண்மையான usage ஒரு நாளைக்கு இரண்டு மணி நேரம் என்றால், வாடகைக்கு எடுத்த GPU வேகமாகவும் குறைந்த செலவாகவும் இருக்கலாம். முதலில் உங்கள் duty cycle-ஐ கணக்கிடுங்கள். அதன் பிறகு cost-ஐ கணக்கிடுங்கள். GPU கொண்ட VPS-ஐத் தேர்ந்தெடுப்பது instance-ல் எதைச் சரிபார்க்க வேண்டும் என்பதை விளக்குகிறது. GPU-ல் concurrent requests-ஐ serve செய்யும்போது, அவற்றைச் சரியாக batch செய்வதால் GPU-ல் concurrent requests-ஐ serve செய்யத் தொடங்கியதும் vLLM, Ollama-வை விட முன்னிலை பெறுகிறது.

மக்கள் அடிக்கடி மறக்கும் மூன்றாவது option ஒன்றும் உள்ளது. Batch work-க்காக 27B-ஐ CPU-ல் வைத்திருங்கள். Interactive path-க்கு முன்னால் hosted API model ஒன்றை அமைக்கவும். இரண்டு பயன்பாடுகளுக்கும் ஒரே model-ஐப் பயன்படுத்த வேண்டும் என்ற கட்டாயம் இல்லை.

Ollama-ஐ நிறுவி உங்கள் server-ஐ அளவிடுங்கள்

நிறுவல் script அதிகாரப்பூர்வமானது. இது தனிப்பட்ட ollama user-ஆக இயங்கும் systemd service-ஐ அமைக்கிறது.

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

ollama --version, Qwen 3.8 27B support கொண்ட முதல் release-ஆன 0.32.12 அல்லது அதற்குப் பிந்தைய பதிப்பை காட்ட வேண்டும். எதையும் pull செய்வதற்கு முன் 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-தான் நீங்கள் தேடிய measurement. Generation நேரத்தில் உங்கள் tokens per second-ஐ eval rate காட்டுகிறது. Prefill speed-ஐ prompt eval rate காட்டுகிறது. Disk-லிருந்து weights-ஐ வாசிக்க எடுத்த நேரத்தை load duration காட்டுகிறது. அதனால் OLLAMA_KEEP_ALIVE=60m அமைக்கப்பட்டுள்ளது: CPU-ல் ஒவ்வொரு request-க்கும் 17 GB-ஐ disk-லிருந்து மீண்டும் load செய்வதற்கான செலவு, request-ன் செலவைவிட அதிகமாக இருக்கலாம். Default idle timeout ஐந்து நிமிடங்கள். Items-க்கு இடையில் இடைவெளி உள்ள batch queue-ல், இந்த load செலவு மீண்டும் மீண்டும் ஏற்படும். ஒரு model-ஐ memory-ல் வைத்திருப்பதற்கான options ஒவ்வொரு request-க்குமான keep_alive field-ஐ அமைப்பதையும், reboot பிறகும் இந்த அமைப்பு நீடிப்பதையும் உள்ளடக்குகின்றன.

Model load செய்யப்பட்டிருக்கும் போது, இரண்டாவது 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-ன் வளரக்கூடிய பகுதி சுமார் கால் gigabyte மட்டுமே. Cache f16-ஆக இருந்தால் அது 0.5 GB ஆக இருக்கும். இதற்கு மேலாக fixed linear-attention state இருக்கும். PROCESSOR column 100% CPU என்று காட்ட வேண்டும். வேறு ஏதாவது காட்டினால், ஏதோ ஒன்று GPU-ஐ பயன்படுத்துகிறது. அப்படியானால் இந்த guide-ல் உள்ள speed numbers உங்கள் server-ஐ பிரதிநிதித்துவப்படுத்தாது.

தோல்வி முறைகள் மற்றும் நீங்கள் காணும் துல்லியமான செய்திகள்

மாதிரியை ஏற்ற முடியவில்லை. 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 சேவை மீண்டும் தொடங்குவதைக் காட்டும். dmesg -T | tail கட்டளையை இயக்கவும்; அதில் Out of memory: Killed process ... (ollama) என்று ஒரு வரி இருந்தால், கர்னலின் OOM killer அதை நிறுத்தியுள்ளது என்று பொருள். முன்-ஏற்றச் சரிபார்ப்பு (pre-load check) சரியாக இருந்தாலும், நீண்ட உரையாடலின் போது cache அளவு கணிப்பை விட அதிகரித்தால் இது நிகழும். Context length-ஐக் குறைக்கவும்.

பதிவிறக்கம் (pull) உடனடியாகத் தோல்வியடைகிறது. Error: pull model manifest: file does not exist என்பது அந்த tag நூலகத்தில் இல்லை என்று பொருள். இன்னும் வெளியிடப்படாத (shipped) ஒரு version எண் அல்லது tag-ல் உள்ள எழுத்துப் பிழை இதற்கு காரணமாக இருக்கலாம். qwen3.8:27b என்பது உண்மையானது, எனவே அந்த குறிப்பிட்ட tag தோல்வியுற்றால், முதலில் எழுத்துப் பிழையைச் சரிபார்க்கவும். உங்கள் network-ஐக் குறை கூறுவதற்கு முன், நூலகப் பக்கத்தில் tag-ஐ உறுதிப்படுத்தவும். ஒரு சரியான tag பதிவிறக்கம் செய்யப்பட்டும் இயங்கவில்லை என்றால், ollama --version-ஐ 0.32.12 உடன் ஒப்பிட்டுச் சரிபார்க்கவும்.

எல்லாம் வேலை செய்கிறது, ஆனால் மிக மெதுவாக உள்ளது. போதுமான RAM இருந்தும் ஒரு வினாடிக்கு ஒரு token-க்கும் குறைவாக இருந்தால், அது கணக்கீட்டை விட paging-ல் சிக்கல் இருப்பதைக் குறிக்கிறது. உருவாக்கம் (generating) நடக்கும்போது vmstat 1 கட்டளையை இயக்கவும். si அல்லது so நெடுவரிசையில் பூஜ்ஜியம் அல்லாத மதிப்பு இருந்தால், கர்னல் swapping செய்கிறது என்று பொருள்; இதற்கு context-ஐக் குறைப்பது அல்லது குறைவான மாதிரிகளை ஏற்றுவது தீர்வாகும். Swap செயல்பாடு இல்லாமல் wa தொடர்ந்து அதிகமாக இருந்தால், memory-mapped weights வட்டில் (disk) இருந்து மீண்டும் மீண்டும் படிக்கப்படுகிறது என்று பொருள்; அதாவது அவை உண்மையில் RAM-ல் பொருந்தவில்லை.

முதல் token வர 30 வினாடிகள் ஆகிறது, பிறகு வேகம் அதிகரிக்கிறது. இது prefill எனப்படும், இது இயல்பானது. Cache-ல் இல்லாத ஒவ்வொரு கோரிக்கைக்கும் நீண்ட system prompt-க்கு நேரம் எடுக்கும், எனவே வேறு எதையும் மாற்றும் முன் 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 நீங்கள் rent செய்து control செய்யும் hardware-ல் இயங்கும். எந்த request-உம் அந்த machine-ஐ விட்டு வெளியேறாது. ஒவ்வொரு token-க்கும் தனிக் கட்டணம் இல்லை. ஒரு வினாடிக்கு மூன்று tokens என்ற வேகத்திலும், regulated data-க்கு இது அதிக மதிப்புடையது. இதை மாற்று வழியுடன் நேர்மையாக ஒப்பிடவும்: frontier-scale model-ஐ self-host செய்ய ஒரு order of magnitude அதிக hardware தேவைப்படும். Output-ஐ இன்னும் படிக்கத் தகுந்ததாக வைத்திருக்கும் அந்த hardware அளவிலான குறைந்த செலவு நிலை 27B on CPU ஆகும்.

இதில் ஏதேனும் ஒன்றை 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 limits ஒவ்வொரு call-க்கும் 500 rows மற்றும் 20 seconds ஆகும். History 1 January 2025 முதல் கிடைக்கிறது. எனவே ஒரு வினாடிக்கு இரண்டு tokens உருவாக்கும் machine பயன்படுத்தக்கூடிய அளவைவிட இது போதுமானது. முழுமையான column list https://ai.strasmore.com/api/demo/schema-ல் உள்ளது.

இது உங்கள் முதல் Ollama install என்றால், VPS-ல் Ollama-ஐ இயக்குவதற்கான முழுமையான walkthrough இந்த guide ஏற்கெனவே அமைக்கப்பட்டதாகக் கருதும் service setup, HTTP API மற்றும் firewall rules ஆகியவற்றை விளக்குகிறது. Port 11434-ஐ internet-க்கு expose செய்ய வேண்டாம். Ollama-ன் local API authentication இல்லாமல் இயங்குகிறது. எனவே அந்த port-ஐ அடையும் எதுவும் உங்கள் model-ஐ பயன்படுத்த முடியும்.

FAQ

Ollama-வில் Qwen 3.8 27B model உள்ளதா?

ஆம். 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 காரணமாக command தோல்வியடையும்.

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 context tokens-க்கும் KV cache சுமார் 1 GB சேர்க்கும். காரணம், model-ன் 64 layers-ல் 16 layers மட்டுமே வளர்ந்து கொண்டிருக்கும் cache-ஐ வைத்திருக்கும். 16 GB plan-ல் weights-ஐ முழுமையாக வைத்திருக்க முடியாது. File memory-mapped செய்யப்பட்டிருப்பதால் swap உதவாது; ஒவ்வொரு token-க்கும் kernel அதை disk-இலிருந்து மீண்டும் படிக்கும். Q8_0 weights 29 GB அளவு கொண்டிருந்தாலும், 64 GB RAM முழு 256K window-க்கு போதுமான இடத்தை வழங்கும்.

CPU-ல் 27B model வினாடிக்கு எத்தனை tokens வழங்கும்?

உங்கள் memory bandwidth-ஐ weights அளவால் வகுக்கவும். பின்னர் கிடைக்கும் மதிப்பின் 50 முதல் 70 சதவீதத்தை எடுத்துக்கொள்ளவும். இரண்டு-channel DDR4-3200 VPS-ன் theoretical ceiling சுமார் 3 tokens per second; நடைமுறையில் சுமார் 2 கிடைக்கும். இரண்டு-channel DDR5-4800 system-ன் ceiling சுமார் 4.5; நடைமுறையில் சுமார் 3 கிடைக்கும். அதிக channels கொண்ட server platforms கணக்கில் சிறப்பாகத் தோன்றும். ஆனால் host-ல் உள்ள அனைத்து tenants-க்கும் memory bandwidth பகிரப்படும். எனவே ollama run qwen3.8:27b --verbose மூலம் உங்கள் system-ஐ அளந்து, 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 RAM நீண்ட context-க்கு இடமளிக்கும். Q8_0 ஒவ்வொரு token-க்கும் கிட்டத்தட்ட இருமடங்கு memory-ஐ நகர்த்தும். இதனால் tokens per second சுமார் பாதியாகக் குறையும். 27B model-ல் Q4_K_M மற்றும் Q8_0 இடையிலான quality வேறுபாடு பெரும்பாலான tasks-க்கு குறைவாக இருக்கும். RAM-ஐ நீண்ட context-க்கு பயன்படுத்தவும். அது model செய்யக்கூடியவற்றை மாற்றும்; பதில்களைச் சொல்லும் முறையை மட்டும் மாற்றாது.

பெரிய 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-க்கு தொடர்ந்து கட்டணம் இருக்கலாம். 64 GB VPS-க்கு model load செய்யப்பட்டுள்ளதா இல்லையா என்பதைப் பொருட்படுத்தாமல் முழு மாதத்திற்கும் கட்டணம் விதிக்கப்படும். ஒரு நாளில் உண்மையில் எத்தனை மணி நேரம் tokens generate செய்கிறீர்கள் என்பதை கணக்கிடவும். Break-even point, rental rates, runtime மற்றும் persistent storage charges ஆகியவற்றைப் பொறுத்தது. தொடர்ந்து இயங்கும் குறைந்த முன்னுரிமை batch வேலைகளுக்கு always-on VPS சாதகமாக இருக்கும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?