SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-22

कितनी RAM में कौन सा AI model self-host कर सकते हैं?

4 GB, 16 GB और 64 GB VPS के लिए model sizing का गणित जानें, CPU token rates समझें और context window की छिपी RAM लागत को सही तरीके से गिनें।

कौन से AI models आप self-host कर सकते हैं, यह कैसे तय होता है

आप कौन से AI models को self-host कर सकते हैं, यह केवल एक संख्या से तय होता है: आपके सर्वर की RAM। मॉडल की श्रेणी और framework इस बात से कहीं कम महत्वपूर्ण हैं कि क्या model weights मेमोरी में फिट होते हैं और उसके बाद कितनी जगह बचती है। यह पोस्ट इस गणना को समझने के लिए है। Runtime install करना एक अलग कार्य है, जिसे the guide to running Ollama on a VPS में कवर किया गया है।

दो लागतें इस उत्तर को निर्धारित करती हैं। Weights एक निश्चित लागत (fixed cost) हैं, जो parameter count और quantisation द्वारा तय होती है। Context window एक चालू लागत (running cost) है, और यही वह चीज है जिसे लोग तब तक भूल जाते हैं जब तक कि कल लोड हुआ मॉडल आज लोड होने से मना न कर दे।

साइजिंग का गणित: प्रति पैरामीटर बिट्स

मॉडल फाइल का अधिकांश हिस्सा वेट्स (weights) से बना होता है। प्रत्येक वेट को कुछ निश्चित बिट्स में स्टोर किया जाता है। क्वांटाइजेशन का अर्थ है उन्हें उस प्रिसिजन (precision) से कम बिट्स में स्टोर करना जिस पर उन्हें ट्रेन किया गया था, जिससे सटीकता में थोड़ी कमी आती है लेकिन मेमोरी की काफी बचत होती है। फाइल का साइज सीधे इसी से निर्धारित होता है:

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

अधिकांश मॉडल 16 बिट्स पर रिलीज किए जाते हैं, जो प्रति बिलियन पैरामीटर 2 GB के बराबर है। कुछ मॉडल पहले से ही आंशिक रूप से क्वांटाइज्ड होकर आते हैं: उदाहरण के लिए, OpenAI का gpt-oss, जिसे इसके mixture of experts वेट्स के साथ 4 bit MXFP4 में पोस्ट-ट्रेन किया गया था। वैसे भी, VPS पर लगभग कोई भी 16 बिट वेट्स नहीं चलाता है। ये वे क्वांटाइजेशन हैं जो आपको वास्तव में मिलेंगे, उनके वास्तविक औसत बिट्स प्रति वेट के साथ:

  • Q8_0 प्रति वेट लगभग 8.5 बिट्स स्टोर करता है, यानी प्रति बिलियन पैरामीटर लगभग 1.1 GB।
  • Q6_K लगभग 6.6 बिट्स स्टोर करता है, यानी प्रति बिलियन लगभग 0.83 GB।
  • Q5_K_M लगभग 5.7 बिट्स स्टोर करता है, यानी प्रति बिलियन लगभग 0.71 GB।
  • Q4_K_M लगभग 4.8 बिट्स स्टोर करता है, यानी प्रति बिलियन लगभग 0.6 GB।

अपनी गणना के लिए प्रति बिलियन पैरामीटर 0.6 GB का उपयोग करें। मेमोरी की कमी वाले सर्वर पर Q4_K_M एक उचित डिफॉल्ट है: अधिकांश कार्यों में 8 बिट्स की तुलना में क्वालिटी का नुकसान कम होता है, और फाइल का साइज लगभग आधा हो जाता है। 4 बिट्स से नीचे नुकसान तेजी से बढ़ता है, इसलिए 2 बिट्स पर कंप्रेस किया गया 70B मॉडल आमतौर पर उसी जनरेशन के 4 बिट्स वाले 32B मॉडल से खराब परिणाम देता है। जब मेमोरी कम हो, तो 4 बिट्स से नीचे जाने के बजाय मॉडल का साइज क्लास कम कर दें।

चार्ट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
  }
]

ऊपर दिया गया वेट कॉलम प्रति बिलियन 0.6 GB के नियम पर आधारित है। वास्तविक GGUF फाइलें इसके कुछ प्रतिशत के भीतर ही रहती हैं, क्योंकि एम्बेडिंग और आउटपुट लेयर्स को बाकी हिस्सों की तुलना में उच्च प्रिसिजन पर रखा जाता है। 4 बिट्स पर 3B मॉडल लगभग 1.8 GB का होता है। 8B मॉडल 4.8 GB का होता है। 32B मॉडल 19.2 GB का होता है, और 70B मॉडल 42 GB का होता है।

Context length के लिए weights की तुलना में अधिक RAM की आवश्यकता क्यों होती है

KV cache (key value cache, वह attention state जिसे model वर्तमान conversation के हर token के लिए सुरक्षित रखता है) दूसरी लागत है। यह model load होने पर allocate होती है, जिसे आपके द्वारा मांगी गई context length के अनुसार आकार दिया जाता है, और यह उस length के साथ सीधे अनुपात में बढ़ती है।

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 के मान 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 खर्च करता है। 128k context पर, जिसका विज्ञापन model card करता है, यह 16 GB खर्च करता है, जो weights से तीन गुना से भी अधिक है। 70B model इसका उल्टा है: 128k पर इसकी cache 40 GB है, जो इसके स्वयं के weights से कम है, क्योंकि grouped query attention प्रति token लागत को parameter count की तुलना में बहुत धीमी गति से बढ़ने देता है।

CPU-only सर्वर पर Ollama की default context length 4096 tokens है। जब GPU मौजूद होता है, तो यह VRAM के आधार पर default चुनता है: 24 से 48 GiB के बीच 32k, और 48 GiB या उससे अधिक पर 256k। इसे सर्वर पर 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 में कुछ कमी आ सकती है।

रेसिडेंट मॉडल उस RAM को तब तक होल्ड करके रखता है जब तक कोई उसे अनलोड न कर दे

Ollama अंतिम अनुरोध के बाद 5 मिनट तक मॉडल को मेमोरी में रखता है, और फिर उसे अनलोड कर देता है। यह डिफ़ॉल्ट सेटिंग लैपटॉप के लिए उपयुक्त है, लेकिन सर्वर के लिए गलत है, जहाँ हर idle गैप के बाद आने वाले पहले अनुरोध पर फिर से लोड होने का समय लगता है।

ollama ps
ollama stop qwen3:4b

ollama ps यह सूची दिखाता है कि क्या रेसिडेंट है, जिसमें SIZE कॉलम यह दर्शाता है कि यह कितनी मेमोरी ले रहा है और UNTIL कॉलम यह दिखाता है कि यह कब समाप्त (expire) होगा। किसी मॉडल को स्थायी रूप से पिन करने के लिए, सर्विस पर 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 पर क्या चलता है

ऑपरेटिंग सिस्टम और मॉडल सर्वर के लिए लगभग 1 GB सुरक्षित रखें, जिससे लगभग 3 GB बचता है। यह 4 bits पर 1B से 4B मॉडल के लिए है, जो डिफ़ॉल्ट 4096 टोकन कॉन्टेक्स्ट पर चलता है। अगस्त 2026 तक, इस श्रेणी में 3B पर Llama 3.2, 1.7B और 4B पर Qwen 3, और छोटे Gemma और Phi releases शामिल हैं। इन्हें केवल आकार के उदाहरण मानें, अनुशंसा नहीं। नाम हर कुछ महीनों में बदलते रहते हैं, लेकिन गणित वही रहता है।

लगभग 6 से 14 टोकन प्रति सेकंड की अपेक्षा रखें। इतने छोटे मॉडल सीमित काम अच्छी तरह करते हैं: वर्गीकरण, टैग निकालना, संक्षिप्त सारांश, और किसी पैराग्राफ को हाउस स्टाइल में फिर से लिखना। वे बहु-चरणीय तर्क (multi-step reasoning) और कई फाइलों में फैले कोड के मामले में कमजोर हैं, और प्रॉम्प्टिंग से इसे ठीक नहीं किया जा सकता।

इस स्तर पर विफलता का मुख्य कारण swap है। यदि मॉडल फिट नहीं होता है, तो Linux उसे लोड करने से मना नहीं करता है। इसके बजाय, यह मेमोरी को डिस्क पर पेज कर देता है, और चूंकि एक टोकन जनरेट करने के लिए हर वेट (weight) को एक बार पढ़ना पड़ता है, इसलिए जनरेशन की गति गिरकर प्रति टोकन कई सेकंड हो जाती है। मॉडल के उत्तर देते समय free -h और vmstat 1 के si और so कॉलम पर नज़र रखें। vmstat आउटपुट की पहली पंक्ति को अनदेखा करें, जो बूट के बाद से सब कुछ का औसत निकालती है, और याद रखें कि काउंटर पूरे सिस्टम को कवर करते हैं, न कि केवल मॉडल को। यदि बॉक्स के खाली रहने पर swap in और swap out शून्य रहते हैं और जनरेशन शुरू होते ही बढ़ जाते हैं, तो इसका मतलब है कि मॉडल इस प्लान के लिए बहुत बड़ा है।

8 GB से 16 GB RAM वाले VPS पर क्या चल सकता है

यहीं पर self-hosted मॉडल वास्तव में उपयोगी हो जाते हैं। 8 GB RAM पर आप 4-bit quantization के साथ 7B या 8B मॉडल चला सकते हैं, जिसमें लगभग 4.8 GB weights और 8k context का उपयोग होता है। 16 GB RAM पर आप 4-bit quantization के साथ 13B या 14B मॉडल चला सकते हैं, जो लगभग 8.4 GB लेते हैं, या यदि आप parameter count के बजाय precision को प्राथमिकता देना चाहते हैं, तो 8B मॉडल को 8-bit पर चला सकते हैं।

गति यहाँ मुख्य बाधा है। CPU पर 8B मॉडल लगभग 3 से 7 tokens प्रति सेकंड generate करता है, और 14B मॉडल लगभग 1.5 से 3.5 tokens प्रति सेकंड। एक सामान्य व्यक्ति लगभग 5 से 10 tokens प्रति सेकंड की गति से पढ़ता है, इसलिए CPU VPS पर 8B मॉडल का अनुभव ऐसा होता है जैसे आप किसी धीमे टाइपिस्ट को काम करते हुए देख रहे हों। यह background jobs के लिए तो ठीक है, लेकिन interactive chat के लिए थकाऊ हो सकता है। VPS पर Qwen 3 के 8B और उससे बड़े मॉडल्स के मापे गए परिणाम दिखाते हैं कि यह व्यवहार में कैसा दिखता है।

32 GB से 64 GB VPS पर क्या चलता है

4-bit पर 32B मॉडल लगभग 19.2 GB का होता है, इसलिए यह छोटे context के साथ 32 GB के प्लान में फिट हो जाता है और 48 GB या 64 GB पर आसानी से चलता है। 4-bit पर 70B मॉडल लगभग 42 GB का होता है, जो Llama 3.3 70B (Q4_K_M) के लिए Ollama द्वारा बताए गए 43 GB के अनुरूप है। यह छोटे context के साथ 48 GB के प्लान में मुश्किल से समाता है और लंबे context के लिए 64 GB की आवश्यकता होती है।

इसके बाद गति को निष्पक्ष रूप से समझें। CPU पर 32B मॉडल लगभग 0.6 से 1.5 tokens प्रति सेकंड की गति से चलता है, और 70B मॉडल 0.2 से 0.5 की गति से। 70B मॉडल से 500 tokens का उत्तर मिलने में लगभग बीस मिनट लगते हैं। इस गति पर, अनुरोध अक्सर मॉडल के पूरा होने से पहले ही समाप्त हो जाता है, क्योंकि Ollama के सामने लगा कोई client या proxy timeout पहले ही trigger हो जाता है, और यहीं से the context deadline exceeded error उत्पन्न होता है। ये batch tools हैं। इन्हें रात भर दस्तावेजों की कतार (queue) दें, तो गति मायने नहीं रखती। यदि इन्हें chat window के पीछे लगाएँ, तो गति बहुत मायने रखती है।

Mixture of experts (MoE) routing इस गणित को बदल देती है, और यह सीखने योग्य एकमात्र architecture detail है। एक MoE मॉडल प्रत्येक token को अपने weights के केवल एक छोटे हिस्से से गुजारता है। 30B कुल parameters और 3B active parameters प्रति token वाला मॉडल 30B जितनी memory लेता है, लेकिन यह 3B के dense मॉडल के करीब की गति से generate करता है, क्योंकि प्रत्येक token केवल active experts को ही पढ़ता है। 32 GB के सर्वर पर इस तरह का MoE मॉडल, 30B के dense मॉडल की तुलना में कहीं अधिक उपयोगी होता है। याद रखने योग्य नियम: कुल parameters memory निर्धारित करते हैं, और active parameters गति निर्धारित करते हैं।

CPU inference वास्तव में कितनी तेज है?

एक token generate करने के लिए हर active weight को एक बार memory से पढ़ना पड़ता है। इससे बचने का कोई तरीका नहीं है, इसलिए CPU पर generation की गति memory bandwidth से तय होती है, न कि core count से। इसकी अधिकतम सीमा एक विभाजन है: उपलब्ध memory bandwidth को bytes में weights के आकार से विभाजित करना। एक छोटा shared VPS आमतौर पर अपने vCPUs के माध्यम से 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 hardware पर देखी जाने वाली ranges हैं, न कि किसी एक machine का benchmark। आपका आंकड़ा memory generation, host पर channels की संख्या, और उस पर compete कर रहे अन्य neighbours पर निर्भर करता है। अपने पास मौजूद किसी भी model tag का उपयोग करके स्वयं मापें:

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

उत्तर समाप्त होने के बाद छपने वाली summary में एक line होती है जो eval rate: ... tokens/s पढ़ती है। यही आपकी generation speed है। session के पहले run को अनदेखा करें, क्योंकि उसी summary पर load duration में weights को disk से पढ़ना भी शामिल होता है। Tokens per second को सही ढंग से मापना में बताया गया है कि तुलना करने योग्य आंकड़ा कैसे प्राप्त करें।

यहाँ दो परिणाम लोगों को हैरान करते हैं। vCPUs जोड़ने से मदद मिलना जल्दी बंद हो जाता है, क्योंकि लगभग 8 cores के बाद अतिरिक्त cores arithmetic करने के बजाय memory का इंतज़ार कर रहे होते हैं। और shared plan पर वही command हर घंटे अलग-अलग numbers देती है, जो कि Noisy neighbour से CPU steal time के कारण होता है, न कि आपकी किसी गलत configuration के कारण।

आपके prompt को पढ़ना, उत्तर generate करने से अलग काम है। Prompt processing compute-bound होती है, इसलिए यह cores के साथ scale करती है, और यही वह जगह है जहाँ GPU सबसे आगे निकल जाता है। एक लंबे document को पढ़ने में CPU को मिनटों का समय लगता है और GPU को सेकंडों का। जब आप किसी coding agent को अपने host किए गए model पर point करते हैं तो यह पहली बाधा है जिसका आप सामना करते हैं, क्योंकि उत्तर का एक भी token आने से पहले हर turn पर file context और tool definitions को फिर से भेजा जाता है।

GPU जोड़ने पर क्या बदलता है

गणित नहीं बदलता, केवल वह पूल बदलता है जिस पर यह लागू होता है। VRAM एक कठोर सीमा है, इसलिए रेंट पर लेने से पहले गणना करें कि क्या फिट होगा:

  • 8 GB VRAM में 4-bit पर 7B या 8B मॉडल छोटे context के साथ आ सकता है।
  • 16 GB में 4-bit पर 14B मॉडल वास्तविक context के साथ, या 8-bit पर 8B मॉडल आ सकता है।
  • 24 GB में 4-bit पर 32B मॉडल छोटे context के साथ आ सकता है।
  • 48 GB में 4-bit पर 70B मॉडल सामान्य context के साथ आ सकता है, और लंबे context तथा concurrency के लिए जगह लगभग 80 GB से शुरू होती है।

जब कोई मॉडल फिट नहीं होता है, तो Ollama उसे विभाजित कर देता है: कुछ layers GPU पर, बाकी CPU पर। ollama ps इस विभाजन को अपने PROCESSOR कॉलम में 78%/22% CPU/GPU जैसे किसी मान के रूप में रिपोर्ट करता है। इसे एक फीचर के बजाय चेतावनी के रूप में पढ़ें। CPU वाला हिस्सा गति निर्धारित करता है, क्योंकि हर टोकन को उन layers पर प्रतीक्षा करनी पड़ती है, इसलिए जिस मॉडल की एक-चौथाई layers CPU पर होती हैं, वह GPU गति के बजाय CPU गति के काफी करीब चलता है। यदि आप ऐसा विभाजन देखते हैं जिसकी आपने योजना नहीं बनाई थी, तो पहले context length को कम करें। आमतौर पर cache ही वह कारण होता है जो इसे सीमा से बाहर ले जाता है।

Concurrency आकार बढ़ाने का दूसरा कारण है। weights को एक साथ आने वाले requests के बीच साझा किया जाता है, लेकिन प्रत्येक सक्रिय request को अपनी KV cache की आवश्यकता होती है, इसलिए 8k context पर 8B मॉडल के दस समवर्ती (concurrent) उपयोगकर्ताओं को weights के अलावा 1 GB cache की आवश्यकता होगी। एक self-hosted मॉडल से समवर्ती उपयोगकर्ताओं को सेवा देना इस बात का विवरण देता है कि यह सीमा कहाँ समाप्त होती है।

क्या GPU रेंट पर लेना फायदेमंद है, यह भी गणित का ही सवाल है, और यह इस बात पर निर्भर करता है कि आप वास्तव में प्रति माह कितने टोकन जनरेट करते हैं। GPU VPS और API टोकन के बीच break even में वे आंकड़े दिए गए हैं।

जिसे आप self-host नहीं कर सकते

यहाँ दो अलग-अलग बाधाएं हैं, और यह जानना मददगार होता है कि आप किस बाधा का सामना कर रहे हैं।

पहली बाधा closed weights है। अग्रणी commercial models वितरित नहीं किए जाते हैं, इसलिए डाउनलोड करने के लिए कोई फाइल नहीं होती है और RAM में कितना भी बदलाव कर लें, इससे कोई फर्क नहीं पड़ता। आप उनके आसपास की हर चीज को self-host कर सकते हैं: interface, retrieval layer, agent loop, और logs। मॉडल स्वयं एक remote API बना रहता है। क्या आप Claude को self-host कर सकते हैं इस विषय पर विस्तार से चर्चा करता है।

दूसरी बाधा open weights हैं जो बहुत बड़े होते हैं। सबसे बड़े open releases में सैकड़ों अरबों total parameters वाले mixture of experts designs शामिल हैं। उन पर भी यही नियम लागू होता है: 4 bits पर 400B total parameter वाले मॉडल को केवल weights के लिए लगभग 240 GB की आवश्यकता होती है, और यह cache से पहले की बात है। यह specialist hardware है, और इसे मासिक किराए पर लेना एक साल में API tokens पर खर्च होने वाली राशि से कहीं अधिक महंगा पड़ता है। Kimi class मॉडल को self-host करने के लिए क्या आवश्यक है वास्तविक आवश्यकताओं के बारे में बताता है। यही अंतर Ollama की अपनी library में भी दिखता है, जहाँ GLM 5.2 को केवल cloud model के रूप में सूचीबद्ध किया गया है और इसका एक छोटा संस्करण ही वह है जो वास्तव में VPS पर डाउनलोड होता है।

इन दोनों के बीच की स्पष्ट रेखा यह है: जब load स्थिर हो और डेटा को आपके सर्वर से बाहर नहीं जाना चाहिए, तब self-host करें। जब load अचानक बढ़ता (bursty) हो, या जब आपको वास्तव में अग्रणी मॉडल की गुणवत्ता की आवश्यकता हो, तब tokens खरीदें।

चुनाव करने से पहले अपनी स्थिति जाँचें

free -h
nproc
lscpu | grep 'Model name'

अपनी योजना available कॉलम के आधार पर बनाएँ, न कि total कॉलम के आधार पर, क्योंकि free -h और total में वह मेमोरी भी शामिल होती है जिसे सिस्टम पहले से उपयोग कर रहा है। ऑपरेटिंग सिस्टम और मॉडल सर्वर के लिए लगभग 1 GB घटा दें। जो बचता है उसे 0.6 से विभाजित करें, इससे आपको 4 bits पर रखे जा सकने वाले अधिकतम पैरामीटर काउंट (बिलियन में) का पता चल जाएगा। इसके बाद उस कॉन्टेक्स्ट के लिए KV cache घटाएँ जो आप वास्तव में चाहते हैं। जो शेष बचता है वही आपका उत्तर है, और मॉडल नामों की सूची के विपरीत यह कभी पुराना नहीं होता।

FAQ

8B मॉडल चलाने के लिए मुझे कितनी RAM की आवश्यकता है?

4 bit क्वांटाइजेशन पर weights के लिए लगभग 4.8 GB, साथ ही आपकी कॉन्टेक्स्ट लेंथ के लिए KV cache, और ऑपरेटिंग सिस्टम व मॉडल सर्वर के लिए लगभग 1 GB। 8192 टोकन कॉन्टेक्स्ट पर cache लगभग 1 GB जोड़ता है, इसलिए 8 GB की योजना काम करेगी और 4 GB की योजना काम नहीं करेगी। यदि आप मॉडल कार्ड द्वारा विज्ञापित पूरा 128k कॉन्टेक्स्ट चाहते हैं, तो केवल cache ही 16 GB का होगा और आपको 32 GB की योजना देखनी होगी।

VPS में पर्याप्त vCPUs होने के बावजूद मेरा मॉडल धीमा क्यों है?

क्योंकि जनरेशन मेमोरी बैंडविड्थ द्वारा सीमित होती है, न कि कोर द्वारा। प्रत्येक टोकन के लिए RAM से पूरे सक्रिय वेट सेट को खींचने की आवश्यकता होती है, इसलिए जैसे ही कुछ कोर मेमोरी चैनलों को संतृप्त (saturate) कर देते हैं, बाकी कोर केवल प्रतीक्षा करते हैं। दूसरा सामान्य कारण स्वैप (swap) है। यदि प्रॉम्प्ट भेजने से पहले vmstat 1 में si और so शून्य दिखाते हैं और मॉडल के उत्तर देते समय ये बढ़ते हैं, तो इसका मतलब है कि weights के RAM में फिट न होने की संभावना अधिक है और प्रत्येक टोकन का एक हिस्सा disk से serve किया जा रहा है, जिसकी लागत जितनी दिखती है उससे कहीं अधिक होती है।

क्या लंबी कॉन्टेक्स्ट विंडो के लिए वास्तव में अधिक मेमोरी की आवश्यकता होती है?

हाँ, और यह वृद्धि टोकन के अनुपात में रैखिक (linear) होती है। एक सामान्य 8B मॉडल प्रति टोकन लगभग 128 KiB KV cache का उपयोग करता है, इसलिए 8192 टोकन की लागत 1 GB और 131072 टोकन की लागत 16 GB होती है। cache को बातचीत बढ़ने के बजाय मॉडल लोड होने पर ही आवंटित कर दिया जाता है, इसलिए 128k कॉन्टेक्स्ट की मांग करने पर वह मेमोरी तुरंत आरक्षित हो जाती है, भले ही आपके द्वारा भेजा गया प्रत्येक प्रॉम्प्ट केवल 200 टोकन लंबा हो।

क्या मुझे 2 bits पर एक बड़ा मॉडल चलाना चाहिए या 4 bits पर एक छोटा मॉडल?

4 bits पर छोटा मॉडल चुनें। 8 bits से 4 bits तक क्वालिटी धीरे-धीरे गिरती है और 4 bits से नीचे तेजी से गिरती है, इसलिए एक ही मॉडल जनरेशन के 32B (4 bits) मॉडल की तुलना में 70B (2 bits) मॉडल आमतौर पर खराब उत्तर देता है। भारी क्वांटाइजेशन त्रुटि संदेश के बजाय दोहराव और छूटे हुए निर्देशों के रूप में दिखाई देता है, जिसे आपके प्रॉम्प्ट की गलती मानना आसान होता है। 4 bits को न्यूनतम सीमा मानें और इसके बजाय पैरामीटर काउंट बदलें।

क्या मैं व्यावसायिक मॉडलों जितना सक्षम मॉडल self-host कर सकता हूँ?

साधारण VPS पर नहीं। सबसे शक्तिशाली ओपन वेट मॉडल सैकड़ों अरबों पैरामीटर तक पहुँचते हैं, जिसका अर्थ है कि 4 bits पर किसी भी KV cache से पहले 200 GB से अधिक RAM की आवश्यकता होती है, और सबसे शक्तिशाली व्यावसायिक मॉडल तो वितरित ही नहीं किए जाते हैं। साधारण हार्डवेयर एक विशिष्ट कार्य के लिए 8B से 32B का अच्छा मॉडल चलाने में सक्षम है, जहाँ एक सीमित और अच्छी तरह से प्रॉम्प्ट किया गया छोटा मॉडल अक्सर एक सामान्य मॉडल के बराबर प्रदर्शन करता है। यदि आपको अत्याधुनिक क्वालिटी चाहिए, तो हार्डवेयर खरीदने से पहले API की कीमत की तुलना हार्डवेयर से करें।

क्या यह लेख उपयोगी था?