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

சொந்தமாக AI மாடல்களை ஹோஸ்ட் செய்வது எப்படி?

உங்கள் கணினியின் RAM அளவிற்கு ஏற்ப எந்த AI மாடல்களை தேர்வு செய்வது என்பதை அறியுங்கள். 4GB, 16GB மற்றும் 64GB VPS-களில் மாடல் அளவு, CPU வேகம் மற்றும் context cost கணக்கீடுகளைப்

எந்த AI மாதிரிகளை நீங்கள் self-host செய்யலாம் என்பதைத் தீர்மானிப்பது எது

எந்த AI மாதிரிகளை நீங்கள் self-host செய்யலாம் என்பதை ஒரு எண் மட்டுமே தீர்மானிக்கிறது: அது உங்கள் கணினியில் உள்ள RAM அளவு. மாதிரியின் வகை (model family) மற்றும் framework-ஐ விட, மாதிரியின் weights நினைவகத்தில் இடம்பிடித்து, மீதமுள்ள இடமும் போதுமானதாக இருக்கிறதா என்பதே முக்கியம். இதைக் கணக்கிடுவதற்கான வழிமுறைகளை இந்தப் பதிவு விளக்குகிறது. Runtime-ஐ நிறுவுவது ஒரு தனி வேலை, அது VPS-ல் Ollama-வை இயக்குவதற்கான வழிகாட்டி-யில் விவரிக்கப்பட்டுள்ளது.

இரண்டு செலவுகள் இந்த முடிவைத் தீர்மானிக்கின்றன. Weights என்பது நிலையான செலவு; இது parameter எண்ணிக்கை மற்றும் quantisation-ஐப் பொறுத்தது. Context window என்பது இயங்கும் செலவு; இதைத்தான் பலரும் கவனிக்கத் தவறிவிடுகிறார்கள். நேற்று சரியாக இயங்கிய ஒரு மாதிரி, இன்று இயங்க மறுப்பதற்கு இதுவே காரணமாகிறது.

அளவு கணக்கீடு: ஒவ்வொரு parameter-க்கும் உள்ள bits

ஒரு model file பெரும்பாலும் weights-ஆகவே இருக்கும். ஒவ்வொரு weight-மும் குறிப்பிட்ட எண்ணிக்கையிலான bits-ல் சேமிக்கப்படும். Quantisation என்பது model பயிற்சி பெற்ற precision-ஐவிடக் குறைவான bits-ல் weights-ஐச் சேமிப்பதாகும். இதனால் accuracy சிறிதளவு குறையும்; memory பயன்பாடு பெருமளவு குறையும். அதன் அளவு நேரடியாக இவ்வாறு கணக்கிடப்படுகிறது:

weights in GB = (parameters in billions x bits per weight) / 8

பெரும்பாலான models 16 bits-ல் release செய்யப்படுகின்றன. இது ஒரு billion parameters-க்கு 2 GB ஆகும். சில models ஏற்கனவே ஓரளவு quantise செய்யப்பட்டிருக்கும். உதாரணமாக, OpenAI-ன் gpt-oss, அதன் mixture of experts weights-ஐ 4 bit MXFP4-ல் post-training செய்துள்ளது. எப்படியிருந்தாலும், VPS-ல் 16 bit weights-ஐ இயக்குவது கிட்டத்தட்ட யாரும் செய்யாதது. நடைமுறையில் நீங்கள் சந்திக்கப்போகும் quantisations இவை. அவற்றின் உண்மையான சராசரி bits per weight பின்வருமாறு:

  • Q8_0 ஒரு weight-க்கு சுமார் 8.5 bits சேமிக்கும். எனவே, ஒரு billion parameters-க்கு சுமார் 1.1 GB தேவைப்படும்.
  • Q6_K சுமார் 6.6 bits சேமிக்கும். எனவே, ஒரு billion parameters-க்கு சுமார் 0.83 GB தேவைப்படும்.
  • Q5_K_M சுமார் 5.7 bits சேமிக்கும். எனவே, ஒரு billion parameters-க்கு சுமார் 0.71 GB தேவைப்படும்.
  • Q4_K_M சுமார் 4.8 bits சேமிக்கும். எனவே, ஒரு billion parameters-க்கு சுமார் 0.6 GB தேவைப்படும்.

உங்கள் கணக்கீட்டில், ஒரு billion parameters-க்கு 0.6 GB என்பதைப் பயன்படுத்துங்கள். Memory குறைவாக உள்ள server-ல் Q4_K_M பொருத்தமான default ஆகும். பெரும்பாலான tasks-ல் 8 bits-உடன் ஒப்பிடும்போது quality loss குறைவாக இருக்கும்; file அளவும் கிட்டத்தட்ட பாதியாக இருக்கும். 4 bits-க்கு கீழே சென்றால் loss விரைவாக அதிகரிக்கும். எனவே, அதே generation-ஐச் சேர்ந்த 4 bits-ல் உள்ள 32B model-ஐவிட, 2 bits-க்கு குறைக்கப்பட்ட 70B model பொதுவாக மோசமாகப் பதிலளிக்கும். Memory குறைவாக இருந்தால், 4 bits-க்கு கீழே செல்வதற்கு முன் ஒரு size class-ஐக் குறைக்கவும்.

விளக்கப்படம்RAM at 4-bit: weights and KV cache, calculated
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "label": "3B",
    "weights_gb": 1.8,
    "kv_8k_gb": 0.9,
    "kv_128k_gb": 14
  },
  {
    "label": "8B",
    "weights_gb": 4.8,
    "kv_8k_gb": 1,
    "kv_128k_gb": 16
  },
  {
    "label": "14B",
    "weights_gb": 8.4,
    "kv_8k_gb": 1.5,
    "kv_128k_gb": 24
  },
  {
    "label": "32B",
    "weights_gb": 19.2,
    "kv_8k_gb": 2,
    "kv_128k_gb": 32
  },
  {
    "label": "70B",
    "weights_gb": 42,
    "kv_8k_gb": 2.5,
    "kv_128k_gb": 40
  }
]

மேலுள்ள weight column, ஒரு billion parameters-க்கு 0.6 GB என்ற விதியைப் பயன்படுத்தி கணக்கிடப்பட்டது. உண்மையான GGUF files இதிலிருந்து சில சதவீதத்திற்குள் இருக்கும். காரணம், embedding மற்றும் output layers மற்ற பகுதிகளைவிட அதிக precision-ல் வைத்திருக்கப்படுகின்றன. 4 bits-ல் உள்ள 3B model சுமார் 1.8 GB ஆகும். 8B model 4.8 GB ஆகும். 32B model 19.2 GB ஆகும்; 70B model 42 GB ஆகும்.

context length weights-ஐ விட அதிக RAM ஏன் தேவைப்படுகிறது

KV cache (key value cache; தற்போது conversation-ல் உள்ள ஒவ்வொரு token-க்கும் model வைத்திருக்கும் attention state) என்பது இரண்டாவது செலவாகும். Model load ஆகும்போது இது allocate செய்யப்படுகிறது. நீங்கள் கேட்ட context length-க்கு ஏற்ப இதன் அளவு நிர்ணயிக்கப்படுகிறது. அந்த length அதிகரிக்கும் போது இதன் அளவும் நேர்கோட்டில் அதிகரிக்கும்.

KV cache formula மற்றும் எண்களை எங்கு பார்க்கலாம்
bytes per token = 2 x layers x kv_heads x head_dim x bytes per element

2 என்பது key மற்றும் value ஆகிய இரண்டையும் குறிக்கிறது. layers, kv_heads (num_key_value_heads என பட்டியலிடப்பட்டுள்ளது) மற்றும் head_dim ஆகியவற்றுக்கான மதிப்புகள் அனைத்தும் model-ன் card page-இல் உள்ள config.json பகுதியில் உள்ளன. 16 bit cache-க்கு ஒரு element-க்கான Bytes மதிப்பு 2 ஆகும். பொதுவான 8B model-ல் 32 layers, 8 key value heads மற்றும் 128 head dimension இருக்கும். ஆகவே 2 x 32 x 8 x 128 x 2 = 131072 bytes; இது ஒவ்வொரு token-க்கும் 128 KiB ஆகும்.

Ollama-வின் default context-ல், அந்த 8B model cache-க்காக அரை gigabyte பயன்படுத்துகிறது. 8192 tokens-ல் அது 1 GB பயன்படுத்துகிறது. அதன் model card விளம்பரப்படுத்தும் 128k context-ல், அது 16 GB பயன்படுத்துகிறது. இது weights-ஐ விட மூன்று மடங்குக்கும் அதிகம். 70B இதற்கு மாறானது: 128k-ல் அதன் cache 40 GB ஆகும். இது அதன் சொந்த weights-ஐ விட குறைவு. ஏனெனில் grouped query attention, parameter count அதிகரிக்கும் வேகத்திற்கு அருகிலும் per-token cost அதிகரிக்காமல் தடுக்கிறது.

CPU மட்டும் உள்ள server-ல் Ollama-வின் default context length 4096 tokens ஆகும். GPU இருந்தால், அது VRAM-லிருந்து default மதிப்பைத் தேர்ந்தெடுக்கும்: 24 முதல் 48 GiB வரை 32k, மற்றும் 48 GiB மற்றும் அதற்கு மேல் 256k. Server-ல் உள்ள OLLAMA_CONTEXT_LENGTH variable மூலம் இதை அதிகரிக்கவும். பின்னர், இயங்கும் model உண்மையில் பெற்ற மதிப்பை ollama ps-ன் CONTEXT column-ல் சரிபார்க்கவும். அந்த ஒரு setting-க்கு பின்னால் உள்ள memory கணக்கீடு num_ctx மற்றும் context length பற்றிய பதிவில் விரிவாக விளக்கப்பட்டுள்ளது.

Cache அளவை மீண்டும் குறைக்க இரண்டு வழிகள் உள்ளன. Model card விளம்பரப்படுத்தும் context-ஐ பயன்படுத்துவதற்குப் பதிலாக, உங்களுக்கு தேவையான context-ஐ கேட்கவும். பெரும்பாலான chat மற்றும் coding பணிகள் 8k முதல் 32k-க்குள் பொருந்தும். அல்லது cache-ஐ 8 bits-ஆகவே quantise செய்யலாம். இதனால் அதன் அளவு பாதியாகும். ஆனால் long context recall-ல் சில இழப்பு ஏற்படும்.

நினைவகத்தில் ஒரு model-ஐத் தக்கவைத்தல்

கடைசி கோரிக்கைக்குப் பிறகு 5 நிமிடங்கள் வரை Ollama ஒரு model-ஐ நினைவகத்தில் வைத்திருந்து, அதன் பிறகு அதை நீக்கிவிடும். இந்த இயல்புநிலை அமைப்பு மடிக்கணினிகளுக்குப் பொருத்தமானது, ஆனால் server-களுக்கு இது உகந்ததல்ல; ஏனெனில் ஒவ்வொரு இடைவெளிக்குப் பிறகும் வரும் முதல் கோரிக்கையின்போது, model-ஐ மீண்டும் ஏற்ற வேண்டிய தாமதம் ஏற்படும்.

ollama ps
ollama stop qwen3:4b

ollama ps கட்டளையானது தற்போது நினைவகத்தில் உள்ளவற்றை பட்டியலிடும். இதில் SIZE நிரல் எவ்வளவு நினைவகத்தை அது ஆக்கிரமித்துள்ளது என்பதையும், UNTIL நிரல் அது எப்போது காலாவதியாகும் என்பதையும் காட்டும். ஒரு model-ஐ நிரந்தரமாக நினைவகத்தில் நிலைநிறுத்த (pin), அந்த service-ல் OLLAMA_KEEP_ALIVE=-1 அமைப்பை மாற்றவும். 0 என்ற மதிப்பை அமைத்தால், ஒவ்வொரு பதிலுக்கும் பிறகு model உடனடியாக நினைவகத்திலிருந்து நீக்கப்படும்.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
sudo systemctl daemon-reload
sudo systemctl restart ollama

ஒரு prompt-ஐ அனுப்பிவிட்டு, பத்து நிமிடங்கள் கழித்து மீண்டும் ollama ps கட்டளையை இயக்கவும். அந்த model இன்னும் பட்டியலில் இருக்கும்; இதுவே இதன் நோக்கம்: யாராவது பயன்படுத்தினாலும் இல்லாவிட்டாலும், அது அந்த RAM-ஐத் தொடர்ந்து ஆக்கிரமித்திருக்கும். நிலைநிறுத்தப்பட்ட (pinned) model என்பது உபரித் திறன் அல்ல. 16 GB RAM கொண்ட VPS-ல், 8k context கொண்ட ஒரு 8B model, service இயங்கும் வரை சுமார் 6 GB-ஐ ஆக்கிரமிக்கும். எனவே, உங்கள் server-ன் அளவைத் தீர்மானிக்கும்போது, model-ன் அளவுடன் உங்கள் application-ன் தேவையையும் சேர்த்து கணக்கிடவும். நினைவகத்தில் ஒரு model-ஐ நிலைநிறுத்துதல் பகுதி, cold start தாமதத்திற்கும் நினைவகப் பயன்பாட்டிற்கும் இடையிலான சமநிலையை விளக்குகிறது.

4 GB VPS-ல் என்ன இயங்கும்

Operating system மற்றும் model server-க்கு சுமார் 1 GB ஒதுக்குங்கள். அப்போது சுமார் 3 GB மீதமாகும். Default 4096 token context-ல் இது 4 bits-ல் இயங்கும் 1B முதல் 4B வரையிலான model-க்கு போதுமானது. August 2026 நிலவரப்படி, இதில் Llama 3.2 at 3B, Qwen 3 at 1.7B மற்றும் 4B, மேலும் சிறிய Gemma மற்றும் Phi releases ஆகியவை அடங்கும். இவற்றை size examples-ஆக மட்டும் கருதுங்கள்; recommendations-ஆக கருத வேண்டாம். Model names சில மாதங்களுக்கு ஒருமுறை மாறும். ஆனால் இந்தக் கணக்கு மாறாது.

ஒரு வினாடிக்கு சுமார் 6 முதல் 14 tokens வரை எதிர்பார்க்கலாம். இவ்வளவு சிறிய models சில குறுகிய பணிகளை நன்றாகச் செய்கின்றன: classification, tag extraction, short summaries, அல்லது ஒரு paragraph-ஐ குறிப்பிட்ட house style-க்கு ஏற்ப rewrite செய்தல். Multi step reasoning மற்றும் பல files-ஐ உள்ளடக்கும் code பணிகளில் இவை பலவீனமாக இருக்கும். எந்த அளவு prompting செய்தாலும் இந்த வரம்பை நீக்க முடியாது.

இந்த tier-ல் பொதுவாக ஏற்படும் failure mode swap ஆகும். Model memory-ல் முழுமையாகப் பொருந்தவில்லை என்றால், Linux அதை load செய்ய மறுக்காது. அதற்கு பதிலாக memory-ஐ disk-க்கு page out செய்யும். ஒரு token-ஐ generate செய்யும்போது ஒவ்வொரு weight-ஐயும் ஒருமுறை படிக்க வேண்டியிருப்பதால், generation ஒரு token-க்கு பல seconds ஆகக் குறையும். Model பதிலளிக்கும்போது free -h மற்றும் vmstat 1-ன் si, so columns-ஐ monitor செய்யுங்கள். vmstat output-ன் முதல் line-ஐப் புறக்கணிக்கவும்; அது boot முதல் ஏற்பட்ட அனைத்தையும் average செய்கிறது. மேலும், இந்த counters model-ஐ மட்டும் அல்ல, முழு system-ஐக் குறிக்கின்றன என்பதை நினைவில் கொள்ளுங்கள். Box idle நிலையில் இருக்கும்போது swap in மற்றும் swap out இரண்டும் zero-வில் இருந்து, generation தொடங்கியவுடன் அதிகரித்தால், அந்த model இந்த plan-க்கு மிகவும் பெரியது என்று பொருள்.

8 GB முதல் 16 GB வரையிலான VPS-ல் இயங்குபவை

இங்குதான் self-hosted மாதிரி பொதுவாகப் பயனுள்ளதாக மாறுகிறது. 8 GB RAM-ல், 4-bit அளவில் 7B அல்லது 8B மாதிரியை, சுமார் 4.8 GB எடையுடன் (weights), 8k context-ல் இயக்கலாம். 16 GB RAM-ல், 4-bit அளவில் 13B அல்லது 14B மாதிரியை, சுமார் 8.4 GB எடையுடன் இயக்கலாம். அல்லது, parameter எண்ணிக்கையை விட துல்லியத்திற்கு (precision) முக்கியத்துவம் அளிக்க விரும்பினால், 8B மாதிரியை 8-bit அளவில் பயன்படுத்தலாம்.

வேகம் தான் இதில் உள்ள சவால். CPU-ல் இயங்கும் ஒரு 8B மாதிரி வினாடிக்கு சுமார் 3 முதல் 7 tokens-ஐ உருவாக்கும்; ஒரு 14B மாதிரி வினாடிக்கு 1.5 முதல் 3.5 tokens-ஐ உருவாக்கும். ஒரு மனிதர் வினாடிக்கு சுமார் 5 முதல் 10 tokens வரை வாசிப்பார். எனவே, CPU VPS-ல் இயங்கும் 8B மாதிரி, மெதுவாகத் தட்டச்சு செய்பவரைப் பார்ப்பது போன்ற உணர்வைத் தரும். இது பின்னணி வேலைகளுக்கு (background jobs) சரியாக இருக்கும், ஆனால் நேரடி உரையாடலுக்கு (interactive chat) சோர்வைத் தரும். VPS-ல் Qwen 3 (8B மற்றும் அதற்கு மேற்பட்டவை) இயக்கப்பட்ட அளவீடுகள் நடைமுறையில் இது எப்படி இருக்கும் என்பதைக் காட்டுகின்றன.

32 முதல் 64 GB VPS-ல் இயங்கக்கூடியவை

4 bits-ல் 32B model சுமார் 19.2 GB ஆகும். எனவே, short context-உடன் இது 32 GB plan-ல் பொருந்தும். 48 GB அல்லது 64 GB plan-ல் இது வசதியாக இயங்கும். 4 bits-ல் 70B model சுமார் 42 GB ஆகும். இது Q4_K_M-ல் Llama 3.3 70B-க்கு Ollama குறிப்பிடும் 43 GB அளவுடன் ஒத்துள்ளது. எனவே, short context-உடன் இது 48 GB plan-ல் சிரமமாகப் பொருந்தும். நீளமான context-க்கு 64 GB தேவைப்படும்.

அடுத்து speed-ஐ நடைமுறைக்கு ஏற்ற வகையில் மதிப்பிடவும். CPU-ல் 32B model ஒரு வினாடிக்கு சுமார் 0.6 முதல் 1.5 tokens வரை உருவாக்கும். 70B model ஒரு வினாடிக்கு 0.2 முதல் 0.5 tokens வரை உருவாக்கும். அந்த 70B model உருவாக்கும் 500-token பதிலுக்கு சுமார் 20 minutes ஆகும். இந்த வேகத்தில், model முடிப்பதற்கு முன்பே request பொதுவாக நிறுத்தப்படும். காரணம், Ollama-க்கு முன்பாக உள்ள ஏதாவது client அல்லது proxy-ன் timeout முதலில் செயல்படும். இதுவே context deadline exceeded error ஏற்படுவதற்கான காரணம். இவை batch tools. ஆவணங்களின் queue-ஐ இரவு முழுவதும் கொடுத்தால் speed முக்கியமல்ல. அவற்றை chat window-க்கு பின்னால் வைத்தால் speed மிகவும் முக்கியமாகும்.

Mixture of experts routing இந்தக் கணக்கீட்டை மாற்றுகிறது. கற்றுக்கொள்ள வேண்டிய ஒரே architecture detail இதுவாகும். MoE model ஒவ்வொரு token-ஐயும் அதன் weights-ன் சிறிய பகுதி வழியாக மட்டுமே அனுப்பும். மொத்தம் 30B parameters மற்றும் token ஒன்றுக்கு 3B active parameters கொண்ட model-க்கு 30B model-க்குத் தேவையான memory தேவைப்படும். ஆனால் இது dense 3B model-ன் வேகத்திற்கு நெருக்கமாக tokens-ஐ உருவாக்கும். காரணம், ஒவ்வொரு token-ம் active experts-ஐ மட்டுமே படிக்கும். 32 GB system-ல் இந்த அமைப்பிலுள்ள MoE, dense 30B model-ஐவிட மிகவும் பயன்படக்கூடியதாக இருக்கும். நினைவில் கொள்ள வேண்டிய விதி: total parameters memory-ஐ நிர்ணயிக்கும்; active parameters speed-ஐ நிர்ணயிக்கும்.

CPU inference உண்மையில் எவ்வளவு வேகமானது?

ஒரு token-ஐ உருவாக்குவதற்கு, நினைவகத்தில் (memory) உள்ள ஒவ்வொரு active weight-ஐயும் ஒருமுறை வாசிக்க வேண்டும். இதைத் தவிர்க்க முடியாது என்பதால், CPU-வில் generation வேகம் என்பது core-களின் எண்ணிக்கையைச் சார்ந்தது அல்ல, அது memory bandwidth-ஐ மட்டுமே சார்ந்தது. இதன் உச்ச வரம்பு ஒரு கணக்கீடு: பயன்படுத்தக்கூடிய memory bandwidth-ஐ, weights-ன் அளவால் (bytes-ல்) வகுக்க வேண்டும். ஒரு சிறிய shared VPS பொதுவாக அதன் vCPU-கள் வழியாக வினாடிக்கு 10 முதல் 25 GB வரை வழங்குகிறது. எனவே, 4.8 GB அளவுள்ள ஒரு model வினாடிக்கு 2 முதல் 5 tokens என்ற அளவில் இயங்கும்.

விளக்கப்படம்Typical reported CPU generation speed at 4-bit on a small VPS
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "label": "3B",
    "tokens_per_second_low": 6,
    "tokens_per_second_high": 14
  },
  {
    "label": "8B",
    "tokens_per_second_low": 3,
    "tokens_per_second_high": 7
  },
  {
    "label": "14B",
    "tokens_per_second_low": 1.5,
    "tokens_per_second_high": 3.5
  },
  {
    "label": "32B",
    "tokens_per_second_low": 0.6,
    "tokens_per_second_high": 1.5
  },
  {
    "label": "70B",
    "tokens_per_second_low": 0.2,
    "tokens_per_second_high": 0.5
  }
]

இவை சாதாரண VPS வன்பொருளில் பொதுவாகக் கிடைக்கும் அளவுகள், ஒரு குறிப்பிட்ட இயந்திரத்தின் benchmark அல்ல. உங்கள் வேகம் என்பது memory தலைமுறை (generation), host-ல் உள்ள channel-களின் எண்ணிக்கை மற்றும் உங்களுடன் போட்டியிடும் பிற பயனர்கள் ஆகியவற்றைப் பொறுத்தது. உங்களிடம் ஏற்கனவே உள்ள ஏதேனும் ஒரு model tag-ஐப் பயன்படுத்தி நீங்களே அளவிடலாம்:

ollama run qwen3:4b --verbose "Write three sentences about disk latency."

பதில் முடிந்ததும் அச்சிடப்படும் சுருக்கத்தின் இறுதியில் eval rate: ... tokens/s என்று தொடங்கும் ஒரு வரி இருக்கும். அதுவே உங்கள் generation வேகம். ஒரு session-ன் முதல் இயக்கத்தைப் புறக்கணிக்கவும், ஏனெனில் அதே சுருக்கத்தில் உள்ள load duration என்பது disk-லிருந்து weights-ஐ வாசிக்கும் நேரத்தையும் உள்ளடக்கியது. Tokens per second-ஐ முறையாக அளவிடுதல் பகுதியில் ஒப்பீடு செய்யத்தக்க மதிப்பை எவ்வாறு பெறுவது என்பது விளக்கப்பட்டுள்ளது.

இங்கே இரண்டு முடிவுகள் மக்களை ஆச்சரியப்படுத்துகின்றன. vCPU-களை அதிகரிப்பது விரைவில் பலனளிக்காமல் போகிறது, ஏனெனில் சுமார் 8 core-களுக்கு மேல், கூடுதல் core-கள் கணக்கீடுகளைச் செய்வதை விட நினைவகத்திற்காகக் காத்திருக்கின்றன. மேலும், shared plan-ல் ஒரே கட்டளை ஒவ்வொரு மணிநேரமும் வெவ்வேறு எண்களைக் காட்டலாம். இது நீங்கள் தவறாக அமைத்ததல்ல, மாறாக CPU steal time from a noisy neighbour ஆகும்.

உங்கள் prompt-ஐ வாசிப்பது, பதிலை உருவாக்குவதிலிருந்து மாறுபட்ட பணியாகும். Prompt processing என்பது compute bound என்பதால், அது core-களின் எண்ணிக்கைக்கு ஏற்ப அதிகரிக்கும். இங்கேயே GPU மற்றவற்றை விட முன்னிலை பெறுகிறது. ஒரு நீண்ட ஆவணத்தை வாசிக்க CPU-க்கு நிமிடங்கள் தேவைப்படும், ஆனால் GPU-க்கு வினாடிகள் மட்டுமே ஆகும். நீங்கள் pointing a coding agent at a model you host செய்யும்போது எதிர்கொள்ளும் முதல் தடையே இதுதான், ஏனெனில் பதிலை உருவாக்குவதற்கு முன்பே, ஒவ்வொரு முறையும் file context மற்றும் tool definitions மீண்டும் அனுப்பப்படுகின்றன.

GPU சேர்த்தால் என்ன மாறும்

கணக்கீடு மாறாது; அது பயன்படுத்தப்படும் pool மட்டும் மாறும். VRAM ஒரு கடினமான வரம்பு. எனவே server-ஐ rent செய்வதற்கு முன் எது பொருந்தும் என்பதை கணக்கிடுங்கள்:

  • 8 GB VRAM, short context உடன் 4 bits-ல் 7B அல்லது 8B model-ஐ வைத்திருக்க முடியும்.
  • 16 GB, real context உடன் 4 bits-ல் 14B model-ஐ அல்லது 8 bits-ல் 8B model-ஐ வைத்திருக்க முடியும்.
  • 24 GB, context-ஐ short-ஆக வைத்தால் 4 bits-ல் 32B model-ஐ வைத்திருக்க முடியும்.
  • 48 GB, modest context உடன் 4 bits-ல் 70B model-ஐ வைத்திருக்க முடியும். Long context மற்றும் concurrency-க்கு போதுமான இடம் பெற, பொதுவாக சுமார் 80 GB தேவைப்படும்.

ஒரு model பொருந்தவில்லை என்றால், Ollama அதை split செய்யும்: சில layers GPU-ல் இருக்கும்; மீதமுள்ளவை CPU-ல் இருக்கும். ollama ps, இந்த split-ஐ அதன் PROCESSOR column-ல் 78%/22% CPU/GPU போன்ற வடிவில் காட்டும். இதை feature-ஆக அல்ல, warning-ஆகக் கருதுங்கள். CPU-ல் உள்ள பகுதி வேகத்தை நிர்ணயிக்கும். ஒவ்வொரு token-மும் அந்த layers-க்காக காத்திருக்க வேண்டியிருப்பதே காரணம். எனவே, layers-ன் கால் பகுதி CPU-ல் உள்ள model, GPU speed-ஐ விட CPU speed-க்கு மிகவும் நெருக்கமாக இயங்கும். நீங்கள் எதிர்பாராத split-ஐ பார்த்தால், முதலில் context length-ஐக் குறைக்கவும். பொதுவாக cache அளவு அதிகரித்ததே இதற்குக் காரணமாக இருக்கும்.

Concurrency-க்காகவும் அதிக VRAM தேவைப்படும். ஒரே நேரத்தில் வரும் requests-க்கு weights பகிரப்படும். ஆனால் செயல்பாட்டில் இருக்கும் ஒவ்வொரு request-க்கும் தனித்தனி KV cache தேவைப்படும். எனவே, 8k context-ல் இயங்கும் 8B model-ஐ ஒரே நேரத்தில் பயன்படுத்தும் பத்து users-க்கு, weights-க்கு மேலாக 1 GB cache-ன் பத்து மடங்கு தேவைப்படும். ஒரே self-hosted model-ல் ஒரே நேரத்தில் பல users-க்கு சேவை வழங்குதல் இந்த ceiling எங்கு அமைகிறது என்பதை விளக்குகிறது.

GPU-ஐ rent செய்வது பயனுள்ளதா என்பதும் ஒரு கணக்கீட்டு கேள்விதான். நீங்கள் உண்மையில் மாதத்திற்கு உருவாக்கும் tokens எண்ணிக்கையைப் பொறுத்தே அது தீர்மானிக்கப்படுகிறது. GPU VPS மற்றும் API tokens இடையிலான break-even point அந்தக் கணக்குகளை வழங்குகிறது.

நீங்கள் எவற்றை self-host செய்ய முடியாது

இங்கே இரண்டு வெவ்வேறு தடைகள் உள்ளன, நீங்கள் எதில் சிக்கியுள்ளீர்கள் என்பதை அறிவது பயனுள்ளதாக இருக்கும்.

முதலாவது closed weights. முன்னணி வணிக ரீதியான மாதிரிகள் (commercial models) விநியோகிக்கப்படுவதில்லை, எனவே பதிவிறக்கம் செய்ய கோப்புகள் எதுவும் இல்லை, RAM-ஐ எவ்வளவு மாற்றினாலும் இதை மாற்ற முடியாது. அவற்றைச் சுற்றியுள்ள அனைத்தையும் நீங்கள் self-host செய்யலாம்: interface, retrieval layer, agent loop, மற்றும் logs. மாதிரி (model) மட்டும் ஒரு remote API-ஆகவே இருக்கும். Claude-ஐ உங்களால் self-host செய்ய முடியுமா என்பது குறித்து அது விரிவாக விளக்குகிறது.

இரண்டாவது, மிகப்பரிய அளவிலான open weights. மிகப்பெரிய open releases என்பவை நூற்றுக்கணக்கான பில்லியன் அளவுள்ள parameters கொண்ட mixture of experts வடிவமைப்புகள் ஆகும். அவற்றுக்கும் அதே விதிதான் பொருந்தும்: 400B total parameter கொண்ட ஒரு மாதிரிக்கு, 4 bits அளவில், cache-க்கு முன்பே weights-க்காக மட்டும் சுமார் 240 GB தேவைப்படும். இது ஒரு சிறப்பு வன்பொருள் (specialist hardware), இதை மாதந்தோறும் வாடகைக்கு எடுப்பது, பெரும்பாலானோர் ஓராண்டில் API tokens-க்காகச் செலவிடும் தொகையை விட மிக அதிகம். Kimi வகை மாதிரியை self-host செய்யத் தேவையானவை என்பது உண்மையான தேவைகளை விளக்குகிறது. இதே வேறுபாடு Ollama-வின் சொந்த library-யிலும் காணப்படுகிறது, அங்கு GLM 5.2 ஒரு cloud model-ஆக மட்டுமே பட்டியலிடப்பட்டுள்ளது, மேலும் அதைவிட மிகச்சிறிய பதிப்பு மட்டுமே VPS-ல் பதிவிறக்கம் செய்யக்கூடியதாக உள்ளது.

இவ்விரண்டிற்கும் இடையிலான தெளிவான வேறுபாடு இதுதான்: சுமை (load) சீராக இருக்கும்போதும், தரவு உங்கள் server-ஐ விட்டு வெளியேறக்கூடாது என்று நினைக்கும்போதும் self-host செய்யுங்கள். சுமை அவ்வப்போது திடீரென அதிகரிக்கும்போதும், அல்லது முன்னணி மாதிரிகளின் துல்லியமான பதில் தரம் உங்களுக்குத் தேவைப்படும்போதும் tokens-ஐ வாங்குங்கள்.

தேர்வு செய்வதற்கு முன் உங்களிடம் உள்ளதைச் சரிபார்க்கவும்

free -h
nproc
lscpu | grep 'Model name'

available நிரலில் உள்ள free -h மதிப்பை அடிப்படையாகக் கொண்டு திட்டமிடுங்கள், total நிரலை அல்ல. ஏனெனில் total என்பது கணினி ஏற்கனவே பயன்படுத்தும் நினைவகத்தையும் உள்ளடக்கியது. இயக்க முறைமை (operating system) மற்றும் model server-க்காக சுமார் 1 GB-ஐக் கழித்துக்கொள்ளுங்கள். மீதமுள்ள மதிப்பை 0.6-ஆல் வகுத்தால், 4 bits-ல் நீங்கள் கையாளக்கூடிய அதிகபட்ச parameter எண்ணிக்கை (பில்லியன் கணக்கில்) கிடைக்கும். அதன் பிறகு, நீங்கள் பயன்படுத்த விரும்பும் context-க்கான KV cache-ஐக் கழித்துவிடுங்கள். எஞ்சியிருப்பதே உங்கள் விடை. இது model பெயர்களின் பட்டியலைப் போல காலாவதியாகாது.

FAQ

8B model-ஐ இயக்க எவ்வளவு RAM தேவை?

4 bit quantisation-ல் weights-க்கு சுமார் 4.8 GB தேவைப்படும். இதனுடன், நீங்கள் பயன்படுத்தும் context length-க்கு ஏற்ப KV cache மற்றும் operating system, model server ஆகியவற்றுக்கு சுமார் 1 GB தேவைப்படும். 8192 token context-ல் cache மேலும் சுமார் 1 GB சேர்க்கும். எனவே 8 GB plan இயங்கும்; 4 GB plan இயங்காது. Model card குறிப்பிடும் முழு 128k context தேவைப்பட்டால், cache மட்டும் 16 GB ஆகும். அப்போது 32 GB plan தேவைப்படும்.

VPS-ல் போதுமான vCPUs இருந்தும் model ஏன் மெதுவாக இயங்குகிறது?

Generation, cores-ஆல் அல்ல memory bandwidth-ஆல் கட்டுப்படுத்தப்படுகிறது. ஒவ்வொரு token-க்கும் active weight set முழுவதையும் RAM-இலிருந்து படிக்க வேண்டும். சில cores memory channels-ஐ முழுமையாகப் பயன்படுத்தத் தொடங்கியதும், மீதமுள்ளவை காத்திருக்கின்றன. மற்றொரு பொதுவான காரணம் swap ஆகும். Prompt அனுப்புவதற்கு முன் vmstat 1, si மற்றும் so ஆகியவற்றில் si மற்றும் so மதிப்புகள் zero-ஆக இருந்து, model பதிலளிக்கும் போது அதிகரித்தால், weights RAM-ல் முழுமையாகப் பொருந்தவில்லை என்று பெரும்பாலும் பொருள். ஒவ்வொரு token-இன் ஒரு பகுதி disk-இலிருந்து வழங்கப்படுகிறது. இதன் செலவு எதிர்பார்ப்பதைவிட அதிகமாக இருக்கும்.

நீண்ட context window-க்கு உண்மையில் அதிக memory தேவையா?

ஆம். Memory பயன்பாடு tokens எண்ணிக்கைக்கு நேர்விகிதத்தில் அதிகரிக்கும். வழக்கமான 8B model ஒன்று ஒவ்வொரு token-க்கும் சுமார் 128 KiB KV cache பயன்படுத்தும். எனவே 8192 tokens-க்கு 1 GB-வும், 131072 tokens-க்கு 16 GB-வும் தேவைப்படும். Conversation நீளமாகும்போது cache ஒதுக்கப்படுவதில்லை. Model load ஆகும் நேரத்திலேயே அது ஒதுக்கப்படும். எனவே நீங்கள் அனுப்பும் ஒவ்வொரு prompt-மும் 200 tokens மட்டுமே இருந்தாலும், 128k context-ஐக் கேட்டால் அந்த memory உடனடியாக reserve செய்யப்படும்.

2 bits-ல் பெரிய model-ஐ இயக்க வேண்டுமா, அல்லது 4 bits-ல் சிறிய model-ஐ இயக்க வேண்டுமா?

4 bits-ல் உள்ள சிறிய model-ஐத் தேர்ந்தெடுக்கவும். 8 bits-இலிருந்து 4 bits வரை quality மெதுவாகக் குறையும். 4 bits-க்குக் கீழே சென்றால் quality வேகமாகக் குறையும். எனவே 70B model-ஐ 2 bits-க்கு சுருக்குவது, அதே model generation-ஐச் சேர்ந்த 32B model-ஐ 4 bits-ல் பயன்படுத்துவதைவிட பொதுவாக மோசமான பதில்களை வழங்கும். Heavy quantisation, error message-ஆக அல்லாமல் repetition மற்றும் instructions தவறவிடுதல் ஆகிய வடிவங்களில் வெளிப்படும். எனவே காரணம் உங்கள் prompt என்று தவறாகக் கருதுவது எளிது. 4 bits-ஐ குறைந்தபட்சமாகக் கருதுங்கள். அதற்குப் பதிலாக parameter count-ஐ மாற்றுங்கள்.

பெரிய commercial models அளவுக்கு திறன் கொண்ட model-ஐ self-host செய்ய முடியுமா?

சாதாரண VPS-ல் முடியாது. வலுவான open weight models நூற்றுக்கணக்கான billions parameters வரை இருக்கும். 4 bits-ல் அவற்றுக்கு KV cache சேர்க்கும் முன்பே 200 GB-க்கும் அதிகமான RAM தேவைப்படும். மேலும், வலுவான commercial models வெளியிடப்படுவதில்லை. சாதாரண hardware-ல் ஒரு குறிப்பிட்ட பணிக்காக நல்ல 8B முதல் 32B model வரை இயக்குவது சிறப்பாகச் செயல்படும். குறுகிய நோக்கத்திற்காகத் தெளிவாக எழுதப்பட்ட prompt-களுடன் பயன்படுத்தப்படும் சிறிய model, பல பணிகளுக்கான பொதுவான model-க்கு இணையான முடிவுகளை வழங்கக்கூடும். Frontier quality தேவைப்பட்டால், hardware வாங்குவதற்கு முன் API செலவை hardware செலவுடன் ஒப்பிடுங்கள்.

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