మీ RAMతో ఏ AI మోడల్స్ను self-host చేయవచ్చు?
మీ వద్ద ఉన్న RAM ఆధారంగా మోడల్ ఎంచుకోండి. 4 GB, 16 GB, 64 GB VPSలకు sizing లెక్కలు, CPU token రేట్లు, context ఖర్చు ఇందులో స్పష్టంగా ఉన్నాయి.
ఏ AI మోడల్స్ను మీరు self-host చేయగలరో నిర్ణయించే అంశాలు
మీరు ఏ AI మోడల్స్ను self-host చేయగలరో అనేది ఒకే ఒక సంఖ్యపై ఆధారపడి ఉంటుంది: అదే మీ సర్వర్లోని RAM. మోడల్ ఫ్యామిలీ లేదా ఫ్రేమ్వర్క్ కంటే, మోడల్ వెయిట్స్ (weights) మెమరీలో సరిపోయి, అదనంగా కొంత స్థలం మిగిలి ఉందా లేదా అన్నదే ముఖ్యం. ఈ పోస్ట్ ఆ గణనను ఎలా చేయాలో వివరిస్తుంది. రన్టైమ్ను ఇన్స్టాల్ చేయడం అనేది వేరే పని, దీని గురించి VPSలో Ollama రన్ చేయడానికి గైడ్ లో చూడవచ్చు.
రెండు ఖర్చులు ఈ నిర్ణయాన్ని ప్రభావితం చేస్తాయి. వెయిట్స్ అనేవి స్థిరమైన ఖర్చు (fixed cost), ఇవి పారామీటర్ల సంఖ్య మరియు క్వాంటైజేషన్ (quantisation) ద్వారా నిర్ణయించబడతాయి. కాంటెక్స్ట్ విండో (context window) అనేది రన్నింగ్ కాస్ట్, దీనిని చాలామంది మర్చిపోతుంటారు; ఫలితంగా నిన్న లోడ్ అయిన మోడల్, ఈరోజు లోడ్ అవ్వడానికి నిరాకరిస్తుంది.
పరిమాణ లెక్కింపు: parameter కు bits
Model file లో దాదాపు మొత్తం weights ఉంటాయి. ప్రతి weight కొన్ని bits పరిమాణంలో నిల్వ చేయబడుతుంది. Quantisation అంటే weights ను అవి training పొందిన precision కంటే తక్కువ bits తో నిల్వ చేయడం. దీనివల్ల accuracy కొద్దిగా తగ్గుతుంది, కానీ memory వినియోగం గణనీయంగా తగ్గుతుంది. పరిమాణం నేరుగా ఇలా లెక్కించవచ్చు:
weights in GB = (parameters in billions x bits per weight) / 8చాలా models 16 bits వద్ద విడుదలవుతాయి. అంటే billion parameters కు 2 GB అవసరం. కొన్ని models ఇప్పటికే కొంత quantised గా వస్తాయి. ఉదాహరణకు, OpenAI యొక్క gpt-oss లో mixture of experts weights ను 4 bit MXFP4 తో post-train చేశారు. అయినప్పటికీ, VPS పై 16 bit weights ను దాదాపు ఎవరూ అమలు చేయరు. మీరు వాస్తవంగా ఉపయోగించే quantisations ఇవి. వీటిలో ప్రతి weight కు ఉండే నిజమైన సగటు bits ఇవి:
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 పరిమితి ఉన్న system లో Q4_K_M సరైన default. చాలా tasks లో 8 bits తో పోలిస్తే quality loss తక్కువగా ఉంటుంది. File పరిమాణం దాదాపు సగానికి తగ్గుతుంది. 4 bits కంటే తక్కువకు వెళితే quality loss వేగంగా పెరుగుతుంది. అందువల్ల అదే generation కు చెందిన 4 bits 32B model కంటే 2 bits కు కుదించిన 70B model సాధారణంగా తక్కువ నాణ్యతతో సమాధానం ఇస్తుంది. Memory తక్కువగా ఉన్నప్పుడు 4 bits కంటే దిగువకు వెళ్లే బదులు ఒక size class తగ్గించండి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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 లో 0.6 GB per billion నియమాన్ని వర్తింపజేశారు. వాస్తవ GGUF files ఈ విలువకు కొన్ని శాతం పరిధిలోనే ఉంటాయి. కారణం, embedding మరియు output layers ను మిగతా 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 (కీ వాల్యూ క్యాష్, అంటే ప్రస్తుతం సంభాషణలో ఉన్న ప్రతి టోకెన్ కోసం మోడల్ ఉంచే అటెన్షన్ స్టేట్) అనేది రెండవ ఖర్చు. మోడల్ లోడ్ అయినప్పుడు ఇది కేటాయించబడుతుంది, మీరు కోరిన కాంటెక్స్ట్ లెంగ్త్ ఆధారంగా దీని పరిమాణం ఉంటుంది, మరియు ఆ లెంగ్త్ పెరిగేకొద్దీ ఇది సరళంగా (linearly) పెరుగుతుంది.
KV cache ఫార్ములా మరియు సంఖ్యలను ఎక్కడ చూడాలి
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 విలువలు అన్నీ మోడల్ కార్డ్ పేజీలోని config.json లో ఉంటాయి. 16-బిట్ క్యాష్ కోసం ప్రతి ఎలిమెంట్కు 2 బైట్లు అవసరం. సాధారణంగా ఒక 8B మోడల్లో 32 లేయర్లు, 8 కీ వాల్యూ హెడ్స్ మరియు 128 హెడ్ డైమెన్షన్ ఉంటాయి, కాబట్టి 2 x 32 x 8 x 128 x 2 = 131072 బైట్లు, అంటే ప్రతి టోకెన్కు 128 KiB.
Ollama డిఫాల్ట్ కాంటెక్స్ట్ వద్ద, ఆ 8B మోడల్ క్యాష్ కోసం అర గిగాబైట్ ఖర్చు చేస్తుంది. 8192 టోకెన్ల వద్ద అది 1 GB ఖర్చు చేస్తుంది. మోడల్ కార్డ్ పేర్కొన్న 128k కాంటెక్స్ట్ వద్ద, అది 16 GB ఖర్చు చేస్తుంది, ఇది మోడల్ వెయిట్స్ కంటే మూడు రెట్లు ఎక్కువ. 70B మోడల్ దీనికి భిన్నంగా ఉంటుంది: 128k వద్ద దాని క్యాష్ 40 GB ఉంటుంది, ఇది దాని వెయిట్స్ కంటే తక్కువ. ఎందుకంటే గ్రూప్డ్ క్వెరీ అటెన్షన్ (grouped query attention) వల్ల ప్రతి టోకెన్ ఖర్చు పారామీటర్ కౌంట్ పెరిగినంత వేగంగా పెరగదు.
CPU మాత్రమే ఉన్న సర్వర్లలో Ollama డిఫాల్ట్ కాంటెక్స్ట్ లెంగ్త్ 4096 టోకెన్లు. GPU ఉన్నప్పుడు, అది VRAM ఆధారంగా డిఫాల్ట్ను ఎంచుకుంటుంది: 24 నుండి 48 GiB మధ్య ఉంటే 32k, 48 GiB మరియు అంతకంటే ఎక్కువ ఉంటే 256k. సర్వర్లో OLLAMA_CONTEXT_LENGTH వేరియబుల్తో దీన్ని పెంచవచ్చు, ఆపై రన్ అవుతున్న మోడల్ వాస్తవానికి ఎంత పొందిందో ollama ps లోని CONTEXT కాలమ్లో తనిఖీ చేయవచ్చు. ఆ ఒక్క సెట్టింగ్ వెనుక ఉన్న మెమరీ గణన గురించి num_ctx మరియు కాంటెక్స్ట్ లెంగ్త్ పై పోస్ట్ లో వివరించబడింది.
క్యాష్ వినియోగాన్ని తగ్గించడానికి రెండు మార్గాలు ఉన్నాయి. మోడల్ కార్డ్ పేర్కొన్న కాంటెక్స్ట్ కాకుండా, మీకు అవసరమైన కాంటెక్స్ట్ను మాత్రమే అడగండి, ఎందుకంటే చాలా చాట్ మరియు కోడింగ్ పనులు 8k నుండి 32k లోపు సరిపోతాయి. లేదా క్యాష్ను 8-బిట్లకు క్వాంటైజ్ (quantise) చేయండి, ఇది దాని పరిమాణాన్ని సగానికి తగ్గిస్తుంది, అయితే దీనివల్ల సుదీర్ఘ కాంటెక్స్ట్ రీకాల్లో కొంత నాణ్యత తగ్గవచ్చు.
మెమరీలో ఉన్న మోడల్ దానిని అన్లోడ్ చేసే వరకు RAMను ఆక్రమిస్తుంది
చివరి అభ్యర్థన తర్వాత Ollama ఒక మోడల్ను 5 నిమిషాల పాటు మెమరీలో ఉంచి, ఆపై అన్లోడ్ చేస్తుంది. ఈ డిఫాల్ట్ సెట్టింగ్ ల్యాప్టాప్లకు సరిపోతుంది, కానీ సర్వర్లకు ఇది సరైనది కాదు. ఎందుకంటే సర్వర్లో ప్రతి idle గ్యాప్ తర్వాత వచ్చే మొదటి అభ్యర్థన మళ్లీ లోడ్ సమయాన్ని తీసుకుంటుంది.
ollama ps
ollama stop qwen3:4bollama ps ప్రస్తుతం మెమరీలో ఉన్న వాటిని జాబితా చేస్తుంది. ఇందులో SIZE కాలమ్ అది ఎంత మెమరీని ఆక్రమిస్తుందో, UNTIL కాలమ్ అది ఎప్పుడు ఎక్స్పైర్ అవుతుందో చూపుతాయి. ఒక మోడల్ను శాశ్వతంగా పిన్ (pin) చేయడానికి, సర్వీస్పై OLLAMA_KEEP_ALIVE=-1 సెట్ చేయండి. 0 విలువను ఇస్తే, ప్రతి రెస్పాన్స్ పూర్తయిన వెంటనే అది అన్లోడ్ అవుతుంది.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"
Environment="OLLAMA_CONTEXT_LENGTH=8192"sudo systemctl daemon-reload
sudo systemctl restart ollamaఒక ప్రాంప్ట్ను పంపి, పది నిమిషాల తర్వాత మళ్లీ ollama ps రన్ చేయండి. మోడల్ ఇంకా జాబితాలోనే ఉంటుంది, ఇదే దీని ముఖ్య ఉద్దేశ్యం: ఎవరూ ఉపయోగించకపోయినా అది ఆ RAMను ఆక్రమించి ఉంటుంది. పిన్ చేసిన మోడల్ ఖాళీ సామర్థ్యం (spare capacity) కాదు. 16 GB VPSలో, 8k కాంటెక్స్ట్తో ఉన్న 8B మోడల్ సర్వీస్ నడుస్తున్నంత సేపు సుమారు 6 GBని ఆక్రమిస్తుంది. కాబట్టి, కేవలం మోడల్ పరిమాణాన్ని మాత్రమే కాకుండా, మోడల్ మరియు మీ అప్లికేషన్ రెండింటినీ కలిపి సర్వర్ సామర్థ్యాన్ని లెక్కించండి. మెమరీలో మోడల్ను పిన్ చేయడం అనే విభాగం కోల్డ్ స్టార్ట్ లేటెన్సీకి మరియు మెమరీ వినియోగానికి మధ్య ఉన్న సమతుల్యతను వివరిస్తుంది.
4 GB VPSపై ఏమి నడుస్తుంది
Operating system మరియు model server కోసం సుమారు 1 GB కేటాయించండి. అప్పుడు దాదాపు 3 GB మిగులుతుంది. Default 4096 token context వద్ద 4 bitsలో ఇది 1B నుంచి 4B model వరకు సరిపోతుంది. August 2026 నాటికి ఈ వర్గంలో 3B పరిమాణంలోని Llama 3.2, 1.7B మరియు 4B పరిమాణాల Qwen 3, అలాగే చిన్న Gemma మరియు Phi releases ఉన్నాయి. వీటిని పరిమాణానికి ఉదాహరణలుగా మాత్రమే పరిగణించండి; సిఫారసులుగా కాదు. ఈ పేర్లు ప్రతి కొన్ని నెలలకు మారుతాయి, కానీ ఈ లెక్క మారదు.
సుమారు 6 నుంచి 14 tokens per second వరకు ఆశించండి. ఇంత చిన్న models కొన్ని పరిమిత పనులను బాగా చేస్తాయి: classification, tag extraction, short summaries, paragraph ను సంస్థ శైలికి అనుగుణంగా rewriting. Multi-step reasoning మరియు అనేక files వ్యాపించే code విషయంలో ఇవి బలహీనంగా ఉంటాయి. ఎంత prompting చేసినా ఈ పరిమితి తొలగదు.
ఈ స్థాయిలో సాధారణంగా ఎదురయ్యే సమస్య swap. Model memoryలో సరిపోకపోతే Linux దాన్ని load చేయడాన్ని నిరాకరించదు. బదులుగా memoryని diskకు page out చేస్తుంది. ఒక tokenను generate చేయడానికి ప్రతి weightను ఒకసారి చదవాల్సి ఉంటుంది కాబట్టి, generation ప్రతి tokenకు seconds పట్టే స్థాయికి నెమ్మదిస్తుంది. Model సమాధానం ఇస్తున్నప్పుడు free -h మరియు vmstat 1 లోని si, so columnsను monitor చేయండి. Boot అయినప్పటి నుంచి వచ్చిన మొత్తం సగటును చూపించే vmstat outputలోని మొదటి lineను పట్టించుకోకండి. ఈ counters modelకు మాత్రమే కాకుండా మొత్తం systemకు వర్తిస్తాయని గుర్తుంచుకోండి. Server idleగా ఉన్నప్పుడు zeroలో ఉండి, generation ప్రారంభమైన వెంటనే పెరిగే swap in మరియు swap out విలువలు, ఆ planకు model చాలా పెద్దదని సూచిస్తాయి.
8 GB నుండి 16 GB VPS పై ఏమి నడుస్తాయి
ఇక్కడే self-hosted మోడల్ సాధారణంగా ఉపయోగకరంగా మారుతుంది. 8 GB RAM ఉన్నప్పుడు, మీరు 4 bits వద్ద 7B లేదా 8B మోడల్ను, సుమారు 4.8 GB బరువులతో (weights), 8k context తో నడపవచ్చు. 16 GB RAM ఉన్నప్పుడు, మీరు 4 bits వద్ద 13B లేదా 14B మోడల్ను, సుమారు 8.4 GB బరువులతో నడపవచ్చు; లేదా పారామీటర్ సంఖ్య కంటే precision (ఖచ్చితత్వం) ముఖ్యమనుకుంటే, 8B మోడల్ను 8 bits వద్ద నడపవచ్చు.
వేగం ఇక్కడ ప్రధాన సమస్య. CPU పై 8B మోడల్ సెకనుకు సుమారు 3 నుండి 7 టోకెన్లను, మరియు 14B మోడల్ సుమారు 1.5 నుండి 3.5 టోకెన్లను ఉత్పత్తి చేస్తుంది. ఒక మనిషి సెకనుకు సుమారు 5 నుండి 10 టోకెన్ల వేగంతో చదవగలడు, కాబట్టి CPU VPS పై 8B మోడల్ నెమ్మదిగా టైప్ చేస్తున్న వ్యక్తిని చూస్తున్నట్లు అనిపిస్తుంది. ఇది బ్యాక్గ్రౌండ్ పనులకు సరిపోతుంది కానీ, ఇంటరాక్టివ్ చాట్ కోసం అయితే అలసట కలిగిస్తుంది. VPS పై Qwen 3 (8B మరియు అంతకంటే పెద్దవి) నడిపినప్పుడు వచ్చిన ఫలితాలు ఆచరణలో ఇది ఎలా ఉంటుందో చూపుతాయి.
32 నుంచి 64 GB VPSపై ఏమి నడుస్తుంది
4 bits వద్ద 32B మోడల్ పరిమాణం సుమారు 19.2 GB ఉంటుంది. అందువల్ల ఇది 32 GB ప్లాన్లో తక్కువ contextతో సరిపోతుంది. 48 GB లేదా 64 GB ప్లాన్లో సౌకర్యంగా నడుస్తుంది. 4 bits వద్ద 70B మోడల్ పరిమాణం సుమారు 42 GB ఉంటుంది. ఇది Q4_K_M వద్ద Llama 3.3 70B కోసం Ollama పేర్కొన్న 43 GBకు సమీపంగా ఉంటుంది. కాబట్టి తక్కువ contextతో 48 GB ప్లాన్లో కష్టంగా సరిపోతుంది. అంతకంటే ఎక్కువ context కోసం 64 GB అవసరం.
తర్వాత వేగాన్ని వాస్తవికంగా అంచనా వేయాలి. CPUపై 32B మోడల్ సెకనుకు సుమారు 0.6 నుంచి 1.5 tokens ఉత్పత్తి చేస్తుంది. 70B మోడల్ సెకనుకు 0.2 నుంచి 0.5 tokens ఉత్పత్తి చేస్తుంది. ఆ 70B మోడల్ నుంచి 500 tokens సమాధానం రావడానికి సుమారు ఇరవై నిమిషాలు పడుతుంది. ఈ వేగంలో మోడల్ పూర్తిచేయకముందే request సాధారణంగా విఫలమవుతుంది. కారణం, Ollama ముందు ఉన్న client లేదా proxyలోని timeout ముందుగా ముగుస్తుంది. అందుకే context deadline exceeded error కనిపిస్తుంది. ఇవి batch పనులకు అనుకూలమైన సాధనాలు. రాత్రంతా documents వరుసను queueలో ఉంచితే వేగం అంత ముఖ్యమైనది కాదు. వాటిని chat window వెనుక ఉంచితే వేగం చాలా ముఖ్యమవుతుంది.
Mixture of experts routing ఈ లెక్కలను మారుస్తుంది. నేర్చుకోవాల్సిన ముఖ్యమైన architecture వివరమిదే. MoE మోడల్ ప్రతి tokenను తన weightsలోని చిన్న భాగం ద్వారా మాత్రమే పంపుతుంది. ఒక మోడల్లో మొత్తం 30B parameters ఉండి, ప్రతి tokenకు 3B parameters activeగా ఉంటే, దానికి 30B మోడల్కు అవసరమైన memory అవసరం అవుతుంది. అయితే ఇది dense 3B మోడల్ వేగానికి దగ్గరగా tokens ఉత్పత్తి చేస్తుంది, ఎందుకంటే ప్రతి token active expertsను మాత్రమే చదువుతుంది. 32 GB boxపై ఈ నిర్మాణంలోని MoE మోడల్ dense 30B మోడల్ కంటే చాలా ఉపయోగకరంగా ఉంటుంది. గుర్తుంచుకోవాల్సిన నియమం: మొత్తం parameters memoryని నిర్ణయిస్తాయి; active parameters వేగాన్ని నిర్ణయిస్తాయి.
CPU inference నిజానికి ఎంత వేగంగా ఉంటుంది?
ఒక token ను generate చేయడానికి ప్రతి active weight ను memory నుంచి ఒకసారి చదవాల్సి ఉంటుంది. దీనిని తప్పించుకోవడం సాధ్యం కాదు, కాబట్టి CPU పై generation వేగం అనేది core ల సంఖ్యపై కాకుండా memory bandwidth పై ఆధారపడి ఉంటుంది. దీని గరిష్ట పరిమితి ఒక విభజన: అందుబాటులో ఉన్న memory bandwidth ను bytes లో ఉన్న weights పరిమాణంతో భాగించాలి. ఒక చిన్న shared VPS సాధారణంగా దాని vCPU ల ద్వారా సెకనుకు 10 నుంచి 25 GB bandwidth ను అందిస్తుంది, కాబట్టి 4.8 GB మోడల్ సెకనుకు 2 నుంచి 5 tokens వేగంతో పనిచేస్తుంది.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"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), హోస్ట్లోని 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 cores దాటిన తర్వాత అదనపు cores గణన (arithmetic) చేయడం కంటే memory కోసం వేచి చూడటమే ఎక్కువ చేస్తాయి. అలాగే, shared plan లో ఒకే command గంట గంటకు వేర్వేరు ఫలితాలను ఇస్తుంది, ఇది మీరు తప్పుగా configure చేయడం వల్ల కాదు, noisy neighbour వల్ల కలిగే CPU steal time వల్ల జరుగుతుంది.
మీ prompt ను చదవడం అనేది సమాధానాన్ని generate చేయడం కంటే భిన్నమైన పని. Prompt processing అనేది compute bound, కాబట్టి ఇది cores సంఖ్యతో పాటు పెరుగుతుంది, ఇక్కడే GPU అత్యధిక వేగాన్ని ప్రదర్శిస్తుంది. ఒక పెద్ద document ను చదవడానికి CPU కి నిమిషాల సమయం పడితే, GPU కి సెకన్ల సమయం మాత్రమే పడుతుంది. మీరు మీరు host చేసిన మోడల్కు coding agent ను అనుసంధానించినప్పుడు ఎదురయ్యే మొదటి అడ్డంకి ఇదే, ఎందుకంటే సమాధానం లోని మొదటి token రాకముందే ప్రతి turn లోనూ file context మరియు tool definitions మళ్ళీ పంపబడతాయి.
GPU జోడించినప్పుడు ఏమి మారుతుంది
లెక్క మారదు. అది వర్తించే pool మాత్రమే మారుతుంది. VRAM ఒక కఠిన పరిమితి. అందువల్ల అద్దెకు తీసుకునే ముందు ఏది సరిపోతుందో లెక్కించండి:
- 8 GB VRAM తక్కువ context తో 4 bits వద్ద 7B లేదా 8B మోడల్ను ఉంచుతుంది.
- 16 GB నిజమైన context తో 4 bits వద్ద 14B మోడల్ను, లేదా 8 bits వద్ద 8B మోడల్ను ఉంచుతుంది.
- 24 GB context ను తక్కువగా ఉంచితే 4 bits వద్ద 32B మోడల్ను ఉంచుతుంది.
- 48 GB మితమైన context తో 4 bits వద్ద 70B మోడల్ను ఉంచుతుంది. దీర్ఘ context మరియు concurrency కోసం ఎక్కువ స్థలం సుమారు 80 GB వద్ద ప్రారంభమవుతుంది.
మోడల్ సరిపోకపోతే Ollama దాన్ని split చేస్తుంది: కొన్ని layers GPUపై, మిగిలినవి CPUపై ఉంటాయి. ollama ps ఈ విభజనను దాని PROCESSOR columnలో 78%/22% CPU/GPU వంటి రూపంలో చూపిస్తుంది. దీన్ని featureగా కాకుండా హెచ్చరికగా పరిగణించండి. వేగాన్ని CPU భాగమే నిర్ణయిస్తుంది. ప్రతి token ఆ layers కోసం ఇంకా వేచి ఉండాలి. అందువల్ల నాలుగో వంతు layers CPUపై ఉన్న మోడల్, GPU speed కంటే CPU speedకు చాలా దగ్గరగా నడుస్తుంది. మీరు ఉద్దేశించని split కనిపిస్తే ముందుగా context length తగ్గించండి. సాధారణంగా cache పరిమితిని దాటడానికి కారణమవుతుంది.
సామర్థ్యాన్ని పెంచుకోవడానికి concurrency కూడా ఒక కారణం. సమకాలిక requests మధ్య weights భాగస్వామ్యం అవుతాయి. అయితే ప్రతి active requestకు స్వంత KV cache అవసరం. అందువల్ల 8k context వద్ద 8B మోడల్ను ఉపయోగించే పది concurrent usersకు weightsకు అదనంగా 1 GB cache అవసరం. ఒక self-hosted మోడల్ నుంచి concurrent usersకు సేవలు అందించడం ద్వారా ఈ పరిమితి ఎక్కడ వర్తిస్తుందో అర్థం చేసుకోవచ్చు.
GPUని అద్దెకు తీసుకోవడం విలువైనదేనా అనేది కూడా ఒక లెక్కింపు ప్రశ్న. మీరు నెలకు వాస్తవంగా ఎన్ని tokens generate చేస్తారన్నదే దీనిపై ఆధారపడి ఉంటుంది. GPU VPS మరియు API tokens మధ్య break-even లో ఆ సంఖ్యలు ఉన్నాయి.
మీరు self-host చేయలేనివి
ఇక్కడ రెండు రకాల అడ్డంకులు ఉన్నాయి, మీరు దేనిని ఎదుర్కొంటున్నారో తెలుసుకోవడం సహాయకరంగా ఉంటుంది.
మొదటిది closed weights. అత్యాధునిక వాణిజ్య నమూనాలు (frontier commercial models) పంపిణీ చేయబడవు, కాబట్టి డౌన్లోడ్ చేయడానికి ఫైల్ ఉండదు, RAM ఎంత పెంచినా ఇది మారదు. మీరు వాటి చుట్టూ ఉన్న ప్రతిదాన్ని self-host చేయవచ్చు: interface, retrieval layer, agent loop, logs. మోడల్ మాత్రం remote API గానే ఉంటుంది. Claude ను self-host చేయవచ్చా అనే అంశం దీని గురించి పూర్తిగా వివరిస్తుంది.
రెండవది, పరిమాణంలో చాలా పెద్దవైన open weights. అతిపెద్ద open releases అనేవి వందల బిలియన్ల పారామీటర్లు కలిగిన mixture of experts డిజైన్లు. వీటికి కూడా అదే నియమం వర్తిస్తుంది: 4 bits వద్ద 400B పారామీటర్ల మోడల్కు, cache కు ముందే కేవలం weights కోసమే సుమారు 240 GB అవసరం. ఇది ప్రత్యేకమైన హార్డ్వేర్, దీనిని నెలవారీ అద్దెకు తీసుకోవడం అనేది చాలా మంది ఏడాదికి API tokens కోసం ఖర్చు చేసే దానికంటే ఎక్కువ. Kimi తరగతి మోడల్ను self-host చేయడానికి కావాల్సినవి అనే కథనం దీనికి అవసరమైన వాస్తవ అవసరాలను వివరిస్తుంది. ఇదే విభజన Ollama లైబ్రరీలో కూడా కనిపిస్తుంది, అక్కడ GLM 5.2 కేవలం cloud మోడల్గా మాత్రమే జాబితా చేయబడింది మరియు దానికంటే చాలా చిన్నదైన మోడల్ మాత్రమే VPS లోకి డౌన్లోడ్ అవుతుంది.
ఈ రెండింటి మధ్య నిజాయితీ గల విభజన ఇది: లోడ్ స్థిరంగా ఉన్నప్పుడు మరియు డేటా మీ సర్వర్ను దాటి వెళ్లకూడదు అనుకున్నప్పుడు self-host చేయండి. లోడ్ అస్థిరంగా ఉన్నప్పుడు లేదా మీకు అత్యుత్తమ నాణ్యత గల సమాధానాలు అవసరమైనప్పుడు tokens కొనుగోలు చేయండి.
ఎంచుకునే ముందు మీ వద్ద ఏముందో తనిఖీ చేయండి
free -h
nproc
lscpu | grep 'Model name'free -h యొక్క available కాలమ్ ఆధారంగా ప్రణాళిక వేసుకోండి, total కాలమ్ ఆధారంగా కాదు. ఎందుకంటే total లో సిస్టమ్ ఇప్పటికే వాడుతున్న మెమరీ కూడా కలిసి ఉంటుంది. ఆపరేటింగ్ సిస్టమ్ మరియు మోడల్ సర్వర్ కోసం సుమారు 1 GB మెమరీని మినహాయించండి. మిగిలిన మొత్తాన్ని 0.6 తో భాగించండి; దీనివల్ల మీరు 4 bits వద్ద ఉంచగలిగే గరిష్ట పారామీటర్ల సంఖ్య (బిలియన్లలో) తెలుస్తుంది. ఆ తర్వాత, మీకు కావలసిన కాంటెక్స్ట్ కోసం KV cache ను మినహాయించండి. మిగిలినదే మీ సమాధానం. మోడల్ పేర్ల జాబితా లాగా ఇది పాతబడిపోదు.
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 విలువలు zeroగా ఉండి, model సమాధానం ఇస్తున్నప్పుడు పెరుగుతున్నట్లయితే, weights RAMలో పూర్తిగా సరిపోకపోవచ్చు. అప్పుడు ప్రతి tokenలో కొంత భాగం disk నుంచి చదవబడుతుంది. దీనివల్ల ఊహించిన దానికంటే చాలా ఎక్కువ ఆలస్యం ఏర్పడుతుంది.
పొడవైన context windowకు నిజంగా ఎక్కువ memory అవసరమా?
అవును. Tokens పెరిగే కొద్దీ memory అవసరం linearగా పెరుగుతుంది. సాధారణ 8B model ప్రతి tokenకు సుమారు 128 KiB KV cache ఉపయోగిస్తుంది. అందువల్ల 8192 tokensకు 1 GB, 131072 tokensకు 16 GB అవసరం. Conversation పొడవు పెరిగినప్పుడు cache allocate కాకుండా, model load అయినప్పుడే allocate అవుతుంది. కాబట్టి మీరు పంపే ప్రతి prompt 200 tokens మాత్రమే ఉన్నప్పటికీ, 128k contextను ఎంచుకుంటే ఆ memory వెంటనే reserve అవుతుంది.
పెద్ద modelను 2 bits వద్ద అమలు చేయాలా, లేక చిన్న modelను 4 bits వద్ద అమలు చేయాలా?
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లో వందల బిలియన్ల parameters ఉంటాయి. 4 bits వద్ద వాటికి ఏ KV cacheకూ ముందు 200 GB కంటే ఎక్కువ RAM అవసరం. అత్యంత శక్తివంతమైన commercial models అసలు పంపిణీ చేయబడవు. సాధారణ hardware ఒక నిర్దిష్ట పనికి మంచి 8B నుంచి 32B modelను అమలు చేయడంలో బాగా ఉపయోగపడుతుంది. పరిమిత లక్ష్యంతో, సరైన prompt ఇచ్చిన చిన్న model తరచుగా general modelతో సమానమైన ఫలితాలు ఇవ్వగలదు. మీకు frontier quality అవసరమైతే, hardware కొనుగోలు చేయడానికి ముందు API ఖర్చును hardware ఖర్చుతో పోల్చండి.