GPU VPS विरुद्ध API tokens: खर्च-समानता कधी होते?
$0.50 प्रति तास GPU VPS साठी मासिक भाडे $365 येते. Frontier आणि small commercial model API च्या तुलनेत खर्च-समानता किती output tokens नंतर होते, याचे सूत्र येथे पाहा.
ब्रेक-इव्हन (break-even) नेमके कुठे आहे
जेव्हा एका GPU VPS चे निश्चित मासिक भाडे, तुम्ही त्या महिन्यात तयार केलेल्या आउटपुट टोकन्सनी भागले असता, ते API द्वारे आकारल्या जाणाऱ्या शुल्कापेक्षा कमी होते, तेव्हा GPU VPS हे प्रति-टोकन API बिलिंगपेक्षा फायदेशीर ठरते. भाडे बदलत नाही. API चे बिल प्रत्येक विनंतीनुसार बदलते. त्यामुळे याचे उत्तर नेहमी मासिक वापराच्या प्रमाणावर अवलंबून असते, केवळ 'हो' किंवा 'नाही' असे नसते.
समजा, $0.50 प्रति तास दराच्या एका मध्यम श्रेणीतील GPU VPS चा विचार करू, ज्याचे 730 तासांच्या महिन्यासाठी $365 भाडे होते. एका फ्रंटियर मॉडेल API च्या तुलनेत, तुम्ही दरमहा 24.3 दशलक्ष आउटपुट टोकन्सवर ब्रेक-इव्हन गाठता. एका लहान व्यावसायिक मॉडेलच्या तुलनेत हे प्रमाण 73 दशलक्ष आहे. त्याच आकाराच्या होस्ट केलेल्या ओपन-वेट मॉडेलच्या तुलनेत तुम्ही कधीही ब्रेक-इव्हन गाठू शकत नाही, कारण एक कार्ड एका महिन्यात इतके टोकन्स तयार करू शकत नाही की ज्यामुळे ते क्रॉसिंग पॉईंटपर्यंत पोहोचेल.
प्रकाशित झालेले ब्रेक-इव्हन अभ्यास या प्रश्नाचे उत्तर देत नाहीत. जुलै 2026 मधील एका विक्रेत्याच्या विश्लेषणानुसार, $2.00 प्रति तास दराच्या एका समर्पित H100 कार्डसाठी सर्व्हरलेस इन्फरन्सच्या तुलनेत 50% वापराच्या आसपास क्रॉसओव्हर असल्याचे म्हटले आहे. अशा प्रकारचे अभ्यास एका समर्पित डेटा-सेंटर कार्डची तुलना सर्व्हरलेस उत्पादनाशी करतात आणि ते ॲक्सिलरेटर्सची किंमत येथे वापरलेल्या तासाच्या दरापेक्षा कित्येक पटीने जास्त धरतात. गणित मात्र सारखेच आहे. खाली दिलेले विश्लेषण एका कार्डसाठी, 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 ची प्रति तास किंमत. GPU निष्क्रिय असताना लागणारे तासही यात धरले आहेत. तुम्ही मासिक शुल्क भरत असल्यास, मासिक किंमत 730 ने भागा.tokens_per_secondम्हणजे तुमच्या प्रत्यक्ष concurrency अंतर्गत सर्व्हरचा स्थिर aggregate output rate. Vendor chart मधील single-stream आकडा येथे वापरू नका.duty_cycleम्हणजे GPU tokens generate करण्यासाठी वापरल्या जाणाऱ्या महिन्याच्या कालावधीचा अंश. तुम्ही संपूर्ण महिना भाड्याने घेतलेला server दररोज दोन तास वापरत असल्यास, हा आकडा 8.3% असेल.api_price_per_millionम्हणजे output tokens साठी ज्या metered price शी तुम्ही तुलना करत आहात ती किंमत.
या उदाहरणात दोन्ही बाजूंना output tokens ची किंमत धरली आहे, कारण chat आणि agent कामामध्ये बिलाचा मुख्य भाग output मुळे येतो. तुमचे prompts मोठे असल्यास, input दोन्ही बाजूंना जोडा. API च्या बाजूला invoice वर त्यासाठी स्वतंत्र ओळ असते. तुमच्या स्वतःच्या card वर prefill साठी GPU time लागतो. त्यामुळे ते आधीच कमी मोजलेल्या tokens_per_second मध्ये दिसते.
विश्वास ठेवण्यापूर्वी tokens per second कसे मोजावे
वरील सर्व गणना एका मोजलेल्या संख्येवर आधारित आहेत. ती संख्या तीनपट चुकीची असल्यास उत्तरही तीनपट चुकीचे असेल. तुम्ही भाड्याने घेतलेल्या card वर, प्रत्यक्षात चालवणार असलेल्या model आणि quantisation सह ती संख्या मोजा.
Ollama मध्ये single-stream आकडा एका command ने मिळतो:
ollama run qwen3:8b --verbose "Write 400 words about disk latency."--verbose उत्तरानंतर timing block दाखवते. महत्त्वाची ओळ eval rate आहे. ती tokens per second मध्ये असते आणि फक्त generation मोजते. prompt eval rate हा prefill speed आहे आणि तो सामान्यतः खूप जास्त असतो. तुमचे आकडे खालील आकड्यांपेक्षा वेगळे असतील:
eval count: 412 token(s)
eval duration: 9.612s
eval rate: 42.86 tokens/sCost model साठी single stream हा चुकीचा आकडा आहे. तो एकावेळी एक request मोजतो, पण card एकाच वेळी अनेक request हाताळू शकतो. Aggregate आकड्यासाठी model vLLM द्वारे serve करा आणि server स्वतःबद्दल दाखवत असलेला throughput वाचा:
pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 8192Requests in flight असताना server प्रत्येक reporting interval ला status line log करतो. vLLM releases नुसार अचूक fields बदलतात. त्यामुळे माझे fields न वापरता तुमचे fields वाचा:
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 आहे. Concurrent requests वाढवत गेल्यावर हा आकडा वाढतो, जोपर्यंत KV cache (key-value cache; vLLM प्रत्येक request साठी VRAM मध्ये ठेवत असलेली attention state) पूर्ण होत नाही. त्यानंतर तो वाढत नाही. त्यापुढे load वाढवल्यास requests अधिक वेगाने पूर्ण होण्याऐवजी queue मध्ये थांबतात. हे वाढणाऱ्या Waiting count मध्ये दिसते. vLLM सोबत vllm bench serve हा load generator देखील येतो. त्याचे flags version नुसार बदलतात. त्यामुळे blog post मधील command कॉपी करण्याऐवजी तुम्ही install केलेल्या version वर vllm bench serve --help चालवा.
Test चालू असताना card चे निरीक्षण करा:
nvidia-smi --query-gpu=utilization.gpu,memory.used,power.draw --format=csv -l 5Generation दरम्यान utilization.gpu जवळपास 100% राहिल्यास तुम्ही throughput-bound आहात आणि मोजलेला आकडा ही वास्तविक कमाल मर्यादा आहे. तो कमी राहिल्यास मर्यादा इतरत्र आहे: concurrent requests फार कमी असणे, client धीमा असणे किंवा model VRAM मध्ये पूर्णपणे न मावल्यामुळे त्याचा काही भाग system RAM मध्ये offload होणे. Ollama आणि vLLM येथे खूप वेगवेगळे trade-offs देतात, आणि त्याच card वर त्यांच्यातील फरक इतका मोठा असू शकतो की break-even अनेक पटींनी बदलतो.
महिनाभरातील बिलाचे स्वरूप
या उदाहरणात $0.50 प्रति तास दराने एक 24 GB GPU VPS वापरला आहे. त्यावर vLLM द्वारे 8B open model दिले जाते. 16 समांतर विनंत्यांसह एकत्रित output दर 400 tokens प्रति सेकंद मोजला आहे. तुम्ही card वापरला किंवा नाही तरी भाडे निश्चितच राहते. या दराने महिन्याला 1,051 million output tokens इतकी क्षमता मिळते. card कधीही थांबत नसेल तर तेवढे output तयार होतात.
या तक्त्यामागील डेटा
[
{
"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 dollars इतकाच स्थिर राहतो, कारण card सोबत तुम्ही काय करता यावर भाड्याचा परिणाम होत नाही. प्रत्येक API खर्चाची रेषा शून्यातून सुरू होणारी सरळ रेषा आहे. प्रत्येक जोडीतील रेषा नेमक्या एकदाच छेदतात.
महिन्याला 25 million output tokens असताना frontier API चे बिल 375 dollars येते. त्यामुळे दोन्ही पर्यायांमधील फरक दहा dollars पेक्षा कमी असतो. 50 million tokens असताना small commercial model चे बिल 250 dollars येते आणि तो अजूनही स्वस्त पर्याय असतो. महिन्याला 1000 million output tokens असताना card महिन्याच्या 95% वेळेत व्यस्त ठेवावा लागतो. त्या वेळी hosted open-weight API चे बिल 200 dollars येते, तर तेवढेच भाडे card साठी द्यावे लागते. card सर्वाधिक कार्यरत असलेल्या याच output प्रमाणावर तो पर्याय जवळपास दुप्पट महाग पडतो.
शेवटचा निष्कर्ष अनेकांना आश्चर्यकारक वाटतो. मात्र तो योगायोग नाही. hosted open-weight endpoint म्हणजे उच्च utilisation वर चालवलेली GPU fleet आहे. त्यामुळे तिची किंमत पूर्ण क्षमतेने वापरल्या जाणाऱ्या card च्या खर्चाच्या जवळ असते. एक card भाड्याने घेऊन तो पूर्ण क्षमतेपेक्षा कमी वापरत असताना saturated fleet पेक्षा कमी खर्च साध्य करता येत नाही. मात्र frontier pricing पेक्षा कमी खर्च साध्य करता येतो. frontier pricing हे silicon time पेक्षा model 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 डॉलर्स. हे दर केवळ उदाहरणासाठी आहेत. कोणताही निर्णय घेण्यापूर्वी आजचे दर तपासा. जर तुमची तुलना मीटर केलेल्या टोकन्सऐवजी फिक्स्ड मंथली प्लॅनशी असेल, तर सबस्क्रिप्शनचे गणित वेगळ्या प्रकारे काम करते आणि ब्रेक-इव्हन पॉईंट बदलतो.
जर तुम्ही GPU पूर्ण क्षमतेने वापरले, तर प्रति दशलक्ष आउटपुट टोकन्सचा खर्च 0.35 डॉलर्स येतो, जो खरोखरच स्वस्त आहे. 10% ड्युटी सायकलवर याच दशलक्ष टोकन्सचा खर्च 3.47 डॉलर्स होतो. 2% ड्युटी सायकलवर हा खर्च 17.36 डॉलर्स होतो, जो होस्ट केलेल्या ओपन मॉडेलच्या 0.20 डॉलर्सच्या तुलनेत खूप जास्त आहे.
होस्ट केलेल्या ओपन-वेट मॉडेलच्या तुलनेत, GPU भाड्याने घेणे हा या चार्टमधील प्रत्येक ड्युटी सायकलवर महागडा पर्याय ठरतो. 10% ड्युटी सायकलवर तुम्ही 3.47 डॉलर्स प्रति दशलक्ष टोकन्स मोजत आहात, ज्याचे बाजारमूल्य 0.20 डॉलर्स आहे. या फरकाची किंमत तुम्ही गोपनीयता आणि स्थिर बिलासाठी मोजत आहात. हे फायदे मौल्यवान असू शकतात, परंतु ते आर्थिकदृष्ट्या स्वस्त नाहीत, त्यामुळे त्यांना तसे समजू नका. कमर्शियल टियर्सच्या तुलनेत चित्र बदलते: 10% ड्युटी सायकलवर हे कार्ड लहान कमर्शियल आणि फ्रंटियर या दोन्ही किमतींपेक्षा स्वस्त पडते आणि ड्युटी सायकल 2.3% पर्यंत खाली येईपर्यंत ते फ्रंटियर टियरपेक्षा स्वस्त राहते.
प्रत्येक API tier साठी break-even volume
या तक्त्यामागील डेटा
[
{
"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 tier च्या तुलनेत तुम्हाला दरमहा 24.3 दशलक्ष output tokens आवश्यक आहेत. हे card च्या क्षमतेच्या केवळ 2.3% इतके आहे. ही मर्यादा कमी आहे. working day मध्ये coding agents चालवणारी छोटी team ती सहज गाठू शकते.
small commercial tier च्या तुलनेत तुम्हाला दरमहा 73 दशलक्ष tokens, म्हणजे 6.9% duty cycle आवश्यक आहे. hosted open-weight tier च्या तुलनेत आवश्यक duty cycle 174% आहे. 100% पेक्षा जास्त मूल्य व्याख्येनुसार साध्य होऊ शकत नाही. त्या card ला महिन्यात उपलब्ध असलेल्या तासांपेक्षा जास्त तास चालावे लागेल. या hourly rate वर एक mid-range card ही तुलना जिंकू शकत नाही. त्यामुळे निकाल बदलण्याचे एकमेव मार्ग म्हणजे स्वस्त card, अधिक वेगवान card किंवा किंमतीशी संबंधित नसलेले कारण.
सूत्र काय लपवते
हे सूत्र GPU तास आणि tokens यांची किंमत मोजते. मात्र अनेक वास्तविक खर्च त्याच्या बाहेर राहतात.
Cold starts. 16-bit weights असलेले 8B model सुमारे 16 GB असते. ते local disk मधून VRAM मध्ये load होण्यासाठी काही दहा सेकंद लागतात. भाडे वाचवण्यासाठी वापरांदरम्यान box बंद केला, तर प्रत्येक वेळी पहिल्या request वेळी हा विलंब सहन करावा लागतो. हा विलंब टाळण्यासाठी box सुरू ठेवला, तर तुमचा duty cycle मोठ्या प्रमाणात कमी होतो आणि प्रति token खर्च वाढतो. Serverless inference असण्यामागचे हेच संपूर्ण कारण आहे.
Storage and download. Weights मोठे असतात. 16-bit मधील 8B model सुमारे 16 GB असते, 4-bit मध्ये quantise केलेले 30B model सुमारे 18 GB असते, आणि 16-bit मधील 30B model 24 GB card वर मुळीच बसत नाही. उच्च क्षमतेच्या model मध्ये ही मर्यादा लवकर स्पष्ट होते. उदाहरणार्थ, Kimi K3 सारखे trillion-parameter open model चालवणे म्हणजे weights चीच मात्रा तुम्ही तासाच्या हिशोबाने भाड्याने घेऊ शकता अशा कोणत्याही single card पेक्षा जास्त होते. त्या disk साठी दर महिन्याला पैसे द्यावे लागतात आणि प्रत्येक rebuild वेळी वेळही खर्च होतो. आठवडाभर प्रयोग केल्यानंतर du -sh ~/.cache/huggingface/hub चालवा. ते तुमच्या अपेक्षेपेक्षा वेगाने वाढते, कारण तुम्ही एकदा वापरून पाहिलेली प्रत्येक quantisation अजूनही तिथेच साठवलेली असते.
तुमचा स्वतःचा वेळ. Driver आणि CUDA versions, कालपर्यंत चाललेल्या context length वर येणाऱ्या out-of-memory errors, तसेच chat template बदलणारे model update—यापैकी काहीही प्रति-token खर्चाच्या आकड्यात दिसत नाही. मात्र या सर्वांचा खर्च तुमच्या मोकळ्या वेळेतून होतो. तुम्ही यापूर्वी अशा box चे sizing केले नसेल, तर महिनाभर भाड्याने घेण्याचा निर्णय करण्यापूर्वी GPU VPS प्रत्यक्षात काय देते हे वाचणे उपयुक्त ठरेल.
गुणवत्तेतील तफावत. हा सर्वात मोठा लपलेला खर्च आहे आणि त्याची किंमत ठरवणे सर्वात कठीण आहे. 8B open model हे frontier model नसते. Frontier model ला एक प्रयत्न पुरत असताना त्याला तीन प्रयत्न लागले, तर उपयुक्त उत्तरामागील त्याची वास्तविक किंमत chart मधील मूल्याच्या तिप्पट होते. त्यातूनही task अयशस्वी होऊ शकते. किंमत पाहण्यापूर्वी तुमच्या स्वतःच्या prompts वर गुणवत्तेची तुलना करा. Agent workloads साठी नेहमीचा उपाय म्हणजे अडचणीनुसार routing करणे आणि मोठ्या प्रमाणातील कामासाठी स्वस्त local tokens वापरणे. VPS वरील agent खर्च नियंत्रित करणे याचा मुख्य भाग हाच आहे.
तुम्ही विसरलेले billing. तुम्ही थांबवलेले hourly GPU instance त्याच्याशी जोडलेल्या storage आणि reserved IP address साठी billing सुरू ठेवू शकते. Price page नव्हे, तर invoice तपासा.
किंमतीव्यतिरिक्त इतर बाबतीत self-hosting कधी फायदेशीर ठरते
गणित हा निर्णायक घटक नसतो अशी चार उदाहरणे.
- तुमच्या नियंत्रणाबाहेर जाऊ नये असा डेटा. एखादा compliance नियम मजकूर third party कडे पाठवण्यास मनाई करत असेल, तर tokenमागील किंमत हा विचारला जाणारा प्रश्नच नसतो.
- ठरावीक वेळापत्रकावर सातत्याने मोठ्या प्रमाणात काम. दररोज रात्री सहा तास चालणारे batch classification काम रचनेनुसार 25% duty cycle वर चालते आणि त्यासाठी अनपेक्षित बिल येत नाही.
- Rate limits. तुमच्या स्वतःच्या card साठी एकच queue असते आणि ती तुमची असते.
- कोणत्याही API वर उपलब्ध नसलेले model. एखादे विशिष्ट fine-tune आवश्यक असल्यास, तुलना करण्यासाठी दुसरा पर्यायच नसतो.
तुम्हाला आधी स्वस्त पर्याय तपासायचा असल्यास, Ollama वापरून VPS वर छोटे model चालवणे यासाठी एका दुपारइतकाच वेळ लागतो. तसेच तुम्ही भाड्याने घेणार असलेल्या card नुसार open model चे sizing करणे यामुळे तुम्हाला प्रत्यक्षात कोणता GPU आवश्यक आहे हे समजते. एका महिन्याचे GPU rent घेण्यापूर्वी तिथेच मोजमाप करा.
FAQ
GPU VPS कधी API किमतीपेक्षा फायदेशीर ठरते?
GPU चे मासिक भाडे API च्या प्रति दशलक्ष आउटपुट टोकन्सच्या किमतीने भागा. जर एका कार्डचे भाडे दरमहा $365 असेल आणि frontier API ची किंमत 15.00 डॉलर्स प्रति दशलक्ष असेल, तर 24.3 दशलक्ष आउटपुट टोकन्सवर खर्च वसूल होतो (break even). लहान कमर्शियल मॉडेलच्या 5.00 डॉलर्सच्या किमतीच्या तुलनेत हे प्रमाण 73 दशलक्ष आहे. होस्ट केलेल्या open-weight मॉडेलच्या 0.20 डॉलर्सच्या किमतीच्या तुलनेत, एक मध्यम क्षमतेचे कार्ड एका महिन्यात इतके टोकन्स तयार करू शकत नाही की खर्च वसूल होईल.
होस्ट केलेल्या open-weight API चा खर्च माझ्या स्वतःच्या GPU पेक्षा कमी का असतो?
कारण त्याची किंमत पूर्ण क्षमतेने वापरल्या जाणाऱ्या GPU च्या खर्चाच्या जवळ निश्चित केलेली असते, तर तुमचे कार्ड पूर्ण क्षमतेने वापरले जात नाही. हजारो विनंत्या हाताळणारा प्रदाता त्याचे सर्व्हर पूर्ण क्षमतेच्या (saturation) जवळ ठेवतो, त्यामुळे तो टोकन्सची विक्री त्यांच्या निर्मितीच्या सीमांत खर्चाच्या (marginal cost) जवळ करू शकतो. तुमचे कार्ड दिवसातील बहुतेक वेळ रिकामे असते आणि तुम्ही त्या रिकाम्या तासांचेही पैसे भरता. 10% duty cycle वर तुमचा खर्च 3.47 डॉलर्स प्रति दशलक्ष आउटपुट टोकन्स येतो, तर त्यांचा खर्च 0.20 डॉलर्स असतो.
मी इनपुट टोकन्स आणि आउटपुट टोकन्स दोन्ही मोजले पाहिजेत का?
जर तुमचे प्रॉम्प्ट्स लांब असतील तर ते मोजा. येथे केलेली तुलना फक्त आउटपुट टोकन्सवर आधारित आहे, जे चॅट आणि एजंटच्या कामासाठी मुख्य घटक आहेत. इनपुट जोडल्यास दोन्ही बाजू बदलतात. API च्या बाजूला, इनव्हाइसवर ही एक स्वतंत्र आणि कमी किमतीची ओळ असते. तुमच्या स्वतःच्या कार्डवर, prefill साठी GPU चा वेळ खर्च होतो, त्यामुळे हा खर्च तुम्ही मोजलेल्या एकूण टोकन्स प्रति सेकंद (tokens per second) मध्ये आधीच समाविष्ट असतो. तुमच्या प्रत्यक्ष प्रॉम्प्ट लांबीसह मोजमाप करा, म्हणजे दोन्ही बाजूंची तुलना करणे शक्य होईल.
सूत्रासाठी आवश्यक असलेले टोकन्स प्रति सेकंद कसे मोजावे?
मॉडेल ज्या प्रकारे वापरणार आहात तसे सर्व्ह करा, त्यानंतर प्रत्यक्ष concurrency अंतर्गत एकूण जनरेशन रेट तपासा. Ollama सह, ollama run <model> --verbose हे टोकन्स प्रति सेकंदात eval rate प्रिंट करते, परंतु तो एकच प्रवाह (single stream) असतो आणि batched सर्व्हरच्या तुलनेत तो कमी आकडा दाखवतो. vLLM सह, चालू असलेला सर्व्हर विनंत्या सुरू असताना Avg generation throughput लॉग करतो, तोच आकडा वापरावा. त्याच वेळी nvidia-smi कडे लक्ष द्या. जर जनरेशन दरम्यान GPU चा वापर (utilisation) 100% च्या जवळ नसेल, तर तुम्ही अजून कमाल मर्यादा (ceiling) गाठलेली नाही.
10% पेक्षा कमी वापरासाठी GPU VPS भाड्याने घेणे योग्य आहे का?
हे तुम्ही कोणत्या API साठी पैसे देणार आहात यावर अवलंबून आहे. 10% duty cycle वर तुमचा खर्च 3.47 डॉलर्स प्रति दशलक्ष आउटपुट टोकन्स येतो, जो लहान कमर्शियल आणि frontier टियर या दोन्हीपेक्षा कमी आहे, परंतु होस्ट केलेल्या open-weight टियरपेक्षा खूप जास्त आहे. 2% वर तुमचा खर्च 17.36 डॉलर्स येतो, जो या तुलनेतील प्रत्येक metered API पेक्षा जास्त आहे, ज्यामध्ये frontier टियरचाही समावेश आहे. केवळ किमतीचा विचार करता, लहान कमर्शियल टियरच्या तुलनेत 6.9% duty cycle वर आणि frontier टियरच्या तुलनेत 2.3% duty cycle वर कार्ड फायदेशीर ठरण्याचे थांबते, आणि होस्ट केलेल्या open-weight मॉडेलच्या तुलनेत ते कधीच फायदेशीर ठरत नाही. या मर्यादेपेक्षा कमी वापरासाठी तेव्हाच भाड्याने घ्या जेव्हा तुम्ही गोपनीयतेसाठी किंवा अशा मॉडेलसाठी पैसे देत असाल जे इतर कोणत्याही API वर उपलब्ध नाही.