GPU VPS बनाम API टोकन: ब्रेक-ईवन पॉइंट कैसे निकालें

ब्रेक-ईवन (break-even) वास्तव में कहाँ स्थित है

GPU VPS, प्रति-टोकन API बिलिंग से एक बिंदु पर बेहतर होता है: जब मासिक निश्चित किराया, उस महीने में आपके द्वारा वास्तव में उत्पन्न किए गए आउटपुट टोकन से विभाजित होने पर, उसी टोकन के लिए API द्वारा लिए जाने वाले शुल्क से कम हो जाता है। किराया नहीं बदलता है। API बिल हर अनुरोध के साथ बदलता है। इसलिए इसका उत्तर हमेशा एक मासिक वॉल्यूम होता है, न कि केवल हाँ या ना।

इसे $0.50 प्रति घंटे वाले मिड-रेंज GPU VPS पर देखें, जो 730 घंटे के महीने के लिए $365 होता है। एक फ्रंटियर मॉडल API के मुकाबले आप प्रति माह 24.3 मिलियन आउटपुट टोकन पर ब्रेक-ईवन करते हैं। एक छोटे कमर्शियल मॉडल के मुकाबले यह 73 मिलियन है। उसी आकार के होस्ट किए गए ओपन-वेट मॉडल के मुकाबले आप कभी ब्रेक-ईवन नहीं करते, क्योंकि एक कार्ड एक महीने में क्रॉसिंग पॉइंट तक पहुँचने के लिए पर्याप्त टोकन उत्पन्न नहीं कर सकता है।

प्रकाशित ब्रेक-ईवन अध्ययन इस प्रश्न का उत्तर नहीं देते हैं। 2026 की शुरुआत के दो अध्ययन H200 पर 72% निरंतर उपयोग के करीब, और MI300X पर 22% से 48% ड्यूटी साइकिल के बीच क्रॉसओवर रखते हैं। दोनों उसी वेंडर के अपने सर्वरलेस उत्पाद के साथ तुलना करते हैं, और दोनों उन एक्सेलेरेटर की कीमत तय करते हैं जो यहाँ अधिकांश पाठकों द्वारा एक महीने में खर्च की जाने वाली राशि से अधिक प्रति घंटा लागत रखते हैं। अंकगणित समान है। नीचे जो दिया गया है वह इसे एक कार्ड, 7B से 30B रेंज में एक ओपन मॉडल, और सामान्य मीटर वाली API बिलिंग के लिए फिर से करता है।

नीचे दी गई प्रत्येक संख्या एक इनपुट है, परिणाम नहीं। उन सभी को अपनी संख्याओं से बदलें।

सूत्र, ताकि आप अपनी संख्याएँ रख सकें

cost_per_million = (hourly_rate * 1000000) / (tokens_per_second * 3600 * duty_cycle)

breakeven_millions_per_month = (hourly_rate * hours_per_month) / api_price_per_million

capacity_millions_per_month = (tokens_per_second * 3600 * hours_per_month) / 1000000

required_duty_cycle = breakeven_millions_per_month / capacity_millions_per_month

चार इनपुट, और आप इन चारों को माप सकते हैं या देख सकते हैं।

• hourly_rate वह लागत है जो GPU VPS के लिए प्रति घंटा लगती है, जिसमें वे घंटे भी शामिल हैं जब यह idle रहता है। यदि आप मासिक भुगतान करते हैं, तो मासिक मूल्य को 730 से विभाजित करें।
• tokens_per_second वह कुल आउटपुट दर है जिसे आपका सर्वर आपकी वास्तविक concurrency के तहत बनाए रखता है। यह किसी वेंडर चार्ट की single-stream संख्या नहीं है।
• duty_cycle महीने का वह हिस्सा है जब GPU tokens generate करने में खर्च होता है। यदि आप पूरे महीने के लिए बॉक्स किराए पर लेते हैं और दिन में दो घंटे उपयोग करते हैं, तो यह 8.3% पर रहता है।
• api_price_per_million वह मापा गया मूल्य है जिसकी आप तुलना कर रहे हैं, जो output tokens के लिए है।

उदाहरण में दोनों तरफ output tokens की कीमत दी गई है, क्योंकि chat और agent कार्य के लिए बिल में output का हिस्सा सबसे अधिक होता है। यदि आपके prompts लंबे हैं, तो दोनों तरफ input जोड़ें। API की तरफ, यह इनवॉइस पर एक अलग पंक्ति होती है। आपके अपने कार्ड पर, prefill GPU समय का उपयोग करता है, इसलिए यह पहले से ही कम मापे गए tokens_per_second के रूप में दिखाई देता है।

गणित पर भरोसा करने से पहले tokens per second को कैसे मापें

ऊपर दी गई हर बात एक मापे गए नंबर पर टिकी है। यदि आप इसमें तीन गुना की भी गलती करते हैं, तो आपका उत्तर भी तीन गुना गलत होगा। इसे उसी कार्ड पर मापें जिसे आप किराए पर ले रहे हैं, और उसी मॉडल तथा quantisation के साथ जिसे आप वास्तव में चलाएंगे।

Ollama आपको एक ही कमांड में single-stream का आंकड़ा दे देता है:

ollama run qwen3:8b --verbose "Write 400 words about disk latency."

--verbose उत्तर के बाद एक timing block प्रिंट करता है। जो लाइन महत्वपूर्ण है वह eval rate है, जो tokens per second में है और केवल generation की गणना करती है। prompt eval rate prefill की गति है और यह सामान्यतः काफी अधिक होती है। आपके नंबर इनसे अलग होंगे:

eval count:       412 token(s)
eval duration:    9.612s
eval rate:        42.86 tokens/s

Single stream एक cost model के लिए गलत नंबर है, क्योंकि यह एक ऐसे कार्ड पर एक बार में एक ही request को मापता है जो एक साथ कई requests को serve कर सकता है। कुल आंकड़े (aggregate figure) के लिए, मॉडल को vLLM के साथ serve करें और उस throughput को पढ़ें जिसे सर्वर स्वयं रिपोर्ट करता है:

pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 8192

जब requests process हो रही होती हैं, तो सर्वर हर reporting interval पर एक status line लॉग करता है। सटीक fields vLLM के अलग-अलग releases के बीच बदलते रहते हैं, इसलिए मेरे बजाय अपने सर्वर के आउटपुट को पढ़ें:

Avg prompt throughput: 812.4 tokens/s, Avg generation throughput: 396.1 tokens/s, Running: 16 reqs, Waiting: 0 reqs, GPU KV cache usage: 21.7%

Avg generation throughput वह नंबर है जिसकी इस formula को आवश्यकता है। जैसे-जैसे आप concurrent requests जोड़ते हैं, यह बढ़ता जाता है जब तक कि KV cache (key-value cache, वह per-request attention state जिसे vLLM VRAM में रखता है) भर न जाए, उसके बाद यह बढ़ना बंद हो जाता है। उससे आगे बढ़ने पर requests तेज होने के बजाय queue में लग जाती हैं, जिसे आप बढ़ते हुए Waiting count के रूप में देखते हैं। vLLM एक load generator, vllm bench serve भी साथ देता है। इसके flags versions के बीच बदलते रहते हैं, इसलिए किसी ब्लॉग पोस्ट से कमांड कॉपी करने के बजाय, अपने द्वारा install किए गए version पर vllm bench serve --help चलाएं।

टेस्ट चलते समय कार्ड पर नज़र रखें:

nvidia-smi --query-gpu=utilization.gpu,memory.used,power.draw --format=csv -l 5

यदि generation के दौरान utilization.gpu 100% के करीब रहता है, तो आप throughput-bound हैं और जो नंबर आपने मापा है वही वास्तविक सीमा है। यदि यह कम रहता है, तो कोई अन्य चीज़ बाधा बन रही है: बहुत कम concurrent requests, एक धीमा client, या ऐसा मॉडल जो VRAM में फिट नहीं हो रहा है और आंशिक रूप से system RAM पर offload हो रहा है। Ollama और vLLM यहाँ बहुत अलग trade-offs करते हैं, और एक ही कार्ड पर उनके बीच का अंतर इतना अधिक है कि यह आपके break-even point को कई गुना बदल सकता है।

महीने भर का बिल कैसा दिखता है

यह उदाहरण एक 24 GB GPU VPS का है जिसका किराया $0.50 प्रति घंटा है। इसमें vLLM द्वारा 8B open model चलाया जा रहा है, जिसकी कुल क्षमता 16 concurrent requests के साथ 400 output tokens प्रति सेकंड है। कार्ड का उपयोग करें या न करें, किराया निश्चित रहता है। इस दर पर क्षमता 1,051 मिलियन output tokens प्रति माह है, जो कि कार्ड के लगातार चलते रहने पर प्राप्त होती है।

[
  {
    "output_tokens_millions": 5,
    "gpu_vps_usd": 365,
    "open_api_usd": 1,
    "small_api_usd": 25,
    "frontier_api_usd": 75
  },
  {
    "output_tokens_millions": 10,
    "gpu_vps_usd": 365,
    "open_api_usd": 2,
    "small_api_usd": 50,
    "frontier_api_usd": 150
  },
  {
    "output_tokens_millions": 25,
    "gpu_vps_usd": 365,
    "open_api_usd": 5,
    "small_api_usd": 125,
    "frontier_api_usd": 375
  },
  {
    "output_tokens_millions": 50,
    "gpu_vps_usd": 365,
    "open_api_usd": 10,
    "small_api_usd": 250,
    "frontier_api_usd": 750
  },
  {
    "output_tokens_millions": 100,
    "gpu_vps_usd": 365,
    "open_api_usd": 20,
    "small_api_usd": 500,
    "frontier_api_usd": 1500
  },
  {
    "output_tokens_millions": 250,
    "gpu_vps_usd": 365,
    "open_api_usd": 50,
    "small_api_usd": 1250,
    "frontier_api_usd": 3750
  },
  {
    "output_tokens_millions": 500,
    "gpu_vps_usd": 365,
    "open_api_usd": 100,
    "small_api_usd": 2500,
    "frontier_api_usd": 7500
  },
  {
    "output_tokens_millions": 1000,
    "gpu_vps_usd": 365,
    "open_api_usd": 200,
    "small_api_usd": 5000,
    "frontier_api_usd": 15000
  }
]

GPU लाइन 365 डॉलर पर स्थिर है क्योंकि किराया इस बात पर निर्भर नहीं करता कि आप कार्ड का उपयोग कैसे करते हैं। प्रत्येक API लाइन शून्य से होकर गुजरने वाली एक सीधी रेखा है। प्रत्येक जोड़ी एक-दूसरे को ठीक एक बार काटती है।

25 मिलियन output tokens प्रति माह पर, frontier API का बिल 375 डॉलर आता है, इसलिए दोनों विकल्पों की लागत में दस डॉलर से कम का अंतर है। 50 मिलियन पर, छोटा commercial model 250 डॉलर का बिल बनाता है और अभी भी सस्ता विकल्प है। 1000 मिलियन output tokens पर, जिसके लिए कार्ड को महीने का 95% समय व्यस्त रहना पड़ता है, hosted open-weight API का बिल उसी किराए के मुकाबले 200 डॉलर आता है। जिस स्तर पर कार्ड सबसे अधिक काम कर रहा है, उसी स्तर पर वह लगभग दोगुने खर्च के साथ पिछड़ जाता है।

यह अंतिम परिणाम लोगों को आश्चर्यचकित करता है, और यह कोई संयोग नहीं है। एक hosted open-weight endpoint उच्च उपयोग (high utilisation) पर चलने वाला GPU fleet है, इसलिए इसकी कीमत एक saturated कार्ड की लागत के करीब होती है। आप एक कार्ड किराए पर लेकर और उसे पूर्ण क्षमता से कम चलाकर एक saturated fleet को मात नहीं दे सकते। आप जिसे मात दे सकते हैं वह है frontier pricing, जो silicon time के बजाय क्षमता (capability) के आधार पर तय की जाती है।

प्रत्येक ड्यूटी साइकिल पर प्रति मिलियन आउटपुट टोकन की लागत

वॉल्यूम और ड्यूटी साइकिल एक ही तथ्य के दो पहलू हैं। रेंट पर लेने का मतलब है घंटों का भुगतान करना। खाली (idle) घंटों में कोई उत्पादन नहीं होता, फिर भी उनका खर्च लगता है।

[
  {
    "label": "100% duty",
    "self_host_usd_per_million": "0.35",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "50% duty",
    "self_host_usd_per_million": "0.69",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "25% duty",
    "self_host_usd_per_million": "1.39",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "10% duty",
    "self_host_usd_per_million": "3.47",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "5% duty",
    "self_host_usd_per_million": "6.94",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "2% duty",
    "self_host_usd_per_million": "17.36",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  }
]

तीन API कॉलम अगस्त 2026 तक प्रकाशित सामान्य लिस्ट कीमतें हैं: होस्ट किए गए 8B ओपन-वेट मॉडल के लिए प्रति मिलियन आउटपुट टोकन 0.20 डॉलर, एक छोटे कमर्शियल मॉडल के लिए 5.00 डॉलर, और एक फ्रंटियर मॉडल के लिए 15.00 डॉलर। ये केवल उदाहरण के लिए हैं। कोई भी निर्णय लेने से पहले आज का प्राइस पेज देखें। यदि आपकी तुलना मीटर किए गए टोकन के बजाय फ्लैट मासिक प्लान से है, तो सब्सक्रिप्शन का गणित अलग तरह से काम करता है और क्रॉसिंग पॉइंट बदल जाता है।

यदि आप कार्ड को पूरी क्षमता पर चलाते हैं, तो एक मिलियन आउटपुट टोकन की लागत 0.35 डॉलर आती है, जो वास्तव में सस्ती है। 10% ड्यूटी साइकिल पर उसी एक मिलियन की लागत 3.47 डॉलर है। 2% ड्यूटी साइकिल पर इसकी लागत 17.36 डॉलर है, जो समान आउटपुट के लिए होस्ट किए गए ओपन मॉडल द्वारा ली जाने वाली 0.20 डॉलर की कीमत की श्रेणी में नहीं आती है।

लगभग 10% ड्यूटी साइकिल से नीचे, GPU रेंट पर लेना महंगा विकल्प है। आप ऐसे आउटपुट के लिए प्रति मिलियन टोकन 3.47 डॉलर का भुगतान कर रहे हैं जो 0.20 डॉलर में बिकता है। इस अंतर के बदले आप गोपनीयता और एक स्थिर बिल खरीद रहे हैं। ये चीजें वास्तविक मूल्य की हो सकती हैं। ये कीमत के मामले में जीत नहीं हैं, इसलिए इन्हें उस रूप में न देखें।

प्रत्येक API टियर के लिए ब्रेक-ईवन वॉल्यूम

[
  {
    "label": "Hosted open 8B API",
    "breakeven_tokens_millions": 1825,
    "required_duty_pct": 174
  },
  {
    "label": "Small commercial model",
    "breakeven_tokens_millions": 73,
    "required_duty_pct": 6.9
  },
  {
    "label": "Frontier model",
    "breakeven_tokens_millions": 24.3,
    "required_duty_pct": 2.3
  }
]

Frontier टियर के मुकाबले आपको प्रति माह 24.3 मिलियन आउटपुट टोकन की आवश्यकता है, जो कार्ड की क्षमता का केवल 2.3% है। यह एक बहुत ही कम सीमा है। कार्य दिवस के दौरान कोडिंग एजेंट्स चलाने वाली एक छोटी टीम इसे आसानी से पार कर लेती है।

Small commercial टियर के मुकाबले आपको प्रति माह 73 मिलियन टोकन, या 6.9% ड्यूटी साइकिल की आवश्यकता है। Hosted open-weight टियर के लिए आवश्यक ड्यूटी साइकिल 174% है। 100% से ऊपर का कोई भी आंकड़ा परिभाषा के अनुसार अप्राप्य है: कार्ड को महीने में उपलब्ध घंटों से अधिक समय तक चलना होगा। इस प्रति-घंटा दर पर एक मिड-रेंज कार्ड इस तुलना में सफल नहीं हो सकता, इसलिए परिणाम बदलने के केवल तीन तरीके हैं: एक सस्ता कार्ड, एक तेज़ कार्ड, या कीमत के अलावा कोई अन्य कारण।

फॉर्मूला क्या छिपाता है

यह फॉर्मूला GPU घंटों और टोकन की कीमत तय करता है। कई वास्तविक लागतें इससे बाहर रहती हैं।

Cold starts. 16-bit weights वाला एक 8B मॉडल लगभग 16 GB का होता है, और इसे लोकल डिस्क से VRAM में लोड करने में दसियों सेकंड लगते हैं। रेंट बचाने के लिए उपयोग के बीच में बॉक्स को बंद करने पर, आपको हर बार पहली रिक्वेस्ट पर उस प्रतीक्षा समय का भुगतान करना पड़ता है। प्रतीक्षा से बचने के लिए इसे चालू रखने पर आपका ड्यूटी साइकिल कम हो जाता है, जिससे प्रति टोकन लागत बढ़ जाती है। यही ट्रेड-ऑफ सर्वरलेस इन्फरेंस (serverless inference) के अस्तित्व का मुख्य कारण है।

स्टोरेज और डाउनलोड। वेट्स (weights) बड़े होते हैं। 16-bit पर 8B मॉडल लगभग 16 GB का होता है, 4-bit पर क्वांटाइज्ड 30B मॉडल लगभग 18 GB का होता है, और 16-bit पर 30B मॉडल 24 GB के कार्ड पर बिल्कुल फिट नहीं होता। ऊपरी स्तर पर यह सीमा जल्दी ही स्पष्ट हो जाती है, जहाँ Kimi K3 जैसे ट्रिलियन-पैरामीटर ओपन मॉडल को चलाना का मतलब है कि केवल वेट्स ही किसी भी ऐसे सिंगल कार्ड से बड़े हो जाते हैं जिसे आप प्रति घंटे के हिसाब से किराए पर ले सकते हैं। आप हर महीने उस डिस्क के लिए भुगतान करते हैं, और हर रीबिल्ड पर समय के रूप में भुगतान करते हैं। प्रयोगों के एक सप्ताह बाद du -sh ~/.cache/huggingface/hub चलाएं। यह आपकी अपेक्षा से अधिक तेजी से बढ़ता है, क्योंकि आपके द्वारा एक बार आजमाया गया हर क्वांटाइजेशन अभी भी वहीं मौजूद होता है।

आपका अपना समय। ड्राइवर और CUDA वर्ज़न, कल काम कर रही कॉन्टेक्स्ट लेंथ पर आउट-ऑफ-मेमोरी एरर, मॉडल अपडेट जो चैट टेम्पलेट को बदल देता है। इनमें से कोई भी प्रति-टोकन लागत के आंकड़े में नहीं दिखता है, और यह सब आपकी शामों की कीमत पर होता है। यदि आपने पहले कभी इन बॉक्सों में से किसी का आकार निर्धारित नहीं किया है, तो GPU VPS वास्तव में आपको क्या देता है को पढ़ना उचित है, इससे पहले कि आप एक महीने के रेंट के लिए प्रतिबद्ध हों।

क्वालिटी गैप। यह सबसे बड़ी छिपी हुई लागत है और इसकी कीमत तय करना सबसे कठिन है। एक 8B ओपन मॉडल फ्रंटियर मॉडल नहीं है। यदि इसे तीन प्रयासों की आवश्यकता है जहाँ फ्रंटियर मॉडल को एक की आवश्यकता है, तो उपयोगी उत्तर के लिए इसकी वास्तविक कीमत चार्ट वैल्यू से तीन गुना है, और यह वैसे भी कार्य में विफल हो सकता है। कीमत पर तुलना करने से पहले अपने स्वयं के प्रॉम्प्ट्स पर तुलना करें। एजेंट वर्कलोड के लिए सामान्य उत्तर कठिनाई के आधार पर रूट करना और सस्ते लोकल टोकन को बल्क वर्क के लिए रखना है, जो कि VPS पर एजेंट खर्च को नियंत्रित करने का मुख्य सार है।

बिलिंग जिसे आप भूल गए। एक प्रति-घंटा GPU इंस्टेंस जिसे आपने बंद कर दिया है, अक्सर अपने अटैच्ड स्टोरेज और रिज़र्व्ड IP एड्रेस के लिए बिलिंग जारी रखता है। प्राइस पेज के बजाय इनवॉइस पढ़ें।

जब self-hosting कीमत के अलावा अन्य कारणों से बेहतर विकल्प होता है

ऐसे चार मामले जहाँ गणितीय गणना निर्णायक कारक नहीं होती है।

• ऐसा डेटा जिसे आप अपने नियंत्रण से बाहर नहीं भेज सकते। यदि कोई compliance नियम किसी तीसरे पक्ष को टेक्स्ट भेजने से रोकता है, तो प्रति टोकन कीमत पर विचार करना प्रासंगिक नहीं रह जाता।
• एक निश्चित शेड्यूल पर स्थिर और अधिक वॉल्यूम। एक बैच क्लासिफिकेशन जॉब जो हर रात छह घंटे चलती है, वह अपनी संरचना के अनुसार 25% ड्यूटी साइकिल पर रहती है, और यह कभी भी अप्रत्याशित बिल नहीं भेजती।
• रेट लिमिट्स। आपके अपने कार्ड की अपनी एक कतार (queue) होती है और वह पूरी तरह से आपके नियंत्रण में होती है।
• ऐसा मॉडल जो कोई API प्रदान नहीं करता। यदि आपको किसी विशिष्ट fine-tune की आवश्यकता है, तो तुलना करने के लिए कोई अन्य विकल्प मौजूद नहीं होता।

यदि आप पहले सस्ते संस्करण का परीक्षण करना चाहते हैं, तो VPS पर Ollama के साथ एक छोटा मॉडल चलाना केवल एक दोपहर का काम है, और किराए पर लिए जाने वाले कार्ड के अनुसार एक ओपन मॉडल का आकार निर्धारित करना आपको यह बताता है कि आपको वास्तव में किस GPU की आवश्यकता है। GPU रेंटल के लिए एक महीने का सब्सक्रिप्शन लेने से पहले वहां माप लें।

FAQ

प्रति माह कितने टोकन वॉल्यूम पर GPU VPS, API प्राइसिंग से सस्ता पड़ता है?

GPU की मासिक लागत को API की प्रति मिलियन आउटपुट टोकन कीमत से विभाजित करें। यदि कोई कार्ड $365 प्रति माह पर उपलब्ध है, और एक frontier API की कीमत 15.00 डॉलर प्रति मिलियन है, तो 24.3 मिलियन आउटपुट टोकन प्रति माह पर लागत बराबर (break even) हो जाती है। एक छोटे कमर्शियल मॉडल के लिए, जिसकी कीमत 5.00 डॉलर है, यह आंकड़ा 73 मिलियन है। एक hosted open-weight मॉडल के लिए, जिसकी कीमत 0.20 डॉलर है, एक mid-range कार्ड एक महीने में इतने टोकन जनरेट नहीं कर सकता कि लागत बराबर हो सके।

एक hosted open-weight API मेरे अपने GPU से सस्ती क्यों है?

क्योंकि इसकी कीमत पूरी तरह से लोड किए गए GPU की लागत के करीब तय की जाती है, और आपका कार्ड पूरी तरह से लोड नहीं होता है। एक प्रदाता जो हजारों concurrent requests को सर्व करता है, अपने fleet को saturation के करीब रखता है, इसलिए वह टोकन को उनके उत्पादन की marginal cost के करीब बेच सकता है। आपका कार्ड दिन के अधिकांश समय idle रहता है और आप उन idle घंटों के लिए भुगतान करते हैं। 10% duty cycle पर आपकी लागत 3.47 डॉलर प्रति मिलियन आउटपुट टोकन है, जबकि उनकी कीमत 0.20 डॉलर है।

क्या मुझे इनपुट टोकन और आउटपुट टोकन दोनों की गणना करनी चाहिए?

यदि आपके prompts लंबे हैं, तो उनकी गणना करें। यहाँ दी गई तुलना केवल आउटपुट टोकन का उपयोग करती है, जो चैट और एजेंट कार्यों के लिए मुख्य कारक है। इनपुट जोड़ने से दोनों पक्ष बदल जाते हैं। API की तरफ, यह इनवॉइस पर एक अलग और कम कीमत वाली लाइन होती है। आपके अपने कार्ड पर, prefill GPU समय का उपयोग करता है, इसलिए लागत पहले से ही आपके द्वारा मापे गए aggregate tokens per second में शामिल है। अपने वास्तविक prompt lengths के साथ मापें ताकि दोनों पक्ष तुलना योग्य रहें।

फॉर्मूला के लिए आवश्यक tokens per second को कैसे मापें?

मॉडल को उस तरह सर्व करें जैसे आप उपयोग करेंगे, फिर वास्तविक concurrency के तहत aggregate generation rate को पढ़ें। Ollama के साथ, ollama run <model> --verbose एक eval rate को tokens per second में प्रिंट करता है, लेकिन यह एक single stream है और batched server की क्षमता को कम करके दिखाता है। vLLM के साथ, चलता हुआ सर्वर requests के दौरान Avg generation throughput लॉग करता है, और यही वह आंकड़ा है जिसका उपयोग करना चाहिए। साथ ही nvidia-smi पर नजर रखें। यदि generation के दौरान GPU utilisation 100% के करीब नहीं है, तो आपने अभी तक अपनी सीमा (ceiling) नहीं खोजी है।

क्या 10% utilisation से नीचे GPU VPS किराए पर लेना उचित है?

कीमत के मामले में नहीं। 10% duty cycle पर आप 3.47 डॉलर प्रति मिलियन आउटपुट टोकन का भुगतान करते हैं, और 2% पर आप 17.36 डॉलर का भुगतान करते हैं। दोनों ही इस तुलना में frontier tier को छोड़कर हर metered API से महंगे हैं। उस सीमा से नीचे तभी किराए पर लें जब आप गोपनीयता (privacy) या किसी ऐसे मॉडल के लिए भुगतान कर रहे हों जो कोई API प्रदान नहीं करता है।