स्थानिक LLM चा tokens per second वेग कसा मोजावा
GPU भाडे API च्या प्रति-टोकन खर्चापेक्षा कधी स्वस्त ठरते? concurrency sweep ने tokens per second अचूक मोजा आणि throughput floor वर निर्णय घ्या.
टोकन प्रति सेकंद GPU वापरणे आर्थिकदृष्ट्या योग्य ठरते की नाही हे का ठरवतात
टोकन प्रति सेकंद हा तुमचा server output text ज्या दराने तयार करतो तो दर आहे. GPU भाड्याने घेणे प्रति टोकन API साठी पैसे देण्यापेक्षा स्वस्त आहे की नाही हे ठरवणारा हाच मुख्य आकडा आहे. GPU box व्यस्त असो किंवा idle असो, त्याचे billing तासानुसार होते. Hosted API चे billing टोकननुसार होते. त्यामुळे तुम्ही ज्या बहुतेक तासांसाठी पैसे देता त्या काळात पुरेसा उच्च output rate राखला, तरच GPU अधिक फायदेशीर ठरतो.
म्हणून कुठेतरी वाचलेला आकडा वापरू नका; प्रत्यक्ष measurement आवश्यक आहे. या पृष्ठावर नोंदवण्यासारखे चार आकडे स्पष्ट केले आहेत. त्यानंतर ते आकडे मिळवण्यासाठीच्या commands आणि त्यांचे arithmetic देण्यात आले आहे, ज्यामुळे योग्य निर्णय घेता येतो.
प्रकाशित tokens per second आकडा तुमच्या सर्व्हरचा आकडा का नसतो
DigitalOcean ने July 2026 मध्ये llama3.3-70b-instruct FP8 (8-bit floating point) मध्ये, vLLM अंतर्गत चालणाऱ्या एका NVIDIA H200 साठी throughput चे आकडे प्रकाशित केले. हे आकडे उपयुक्त आहेत; मात्र ते तुमच्या सर्व्हरचे आकडे नाहीत.
या तक्त्यामागील डेटा
[
{
"config": "H200, one stream",
"tok_s": "47"
},
{
"config": "H100, saturated",
"tok_s": "236"
},
{
"config": "H200, saturated",
"tok_s": "2,036"
},
{
"config": "H200, saturated, in+out",
"tok_s": "4,071.6"
}
]वरील प्रत्येक row त्या पृष्ठावरून घेतली आहे. त्यांपैकी दोन आकडे दिलेल्या range ची lower bound आहेत. त्यामुळे त्या दोन आकड्यांना किमान क्षमता समजा. या chart मधील कोणताही आकडा आम्ही मोजलेला नाही.
शेवटच्या दोन row पासून सुरुवात करा. Headline आकडा 4,071.6 tok/s आहे, तर output-only rate 2,036 tok/s आहे. Headline मध्ये input आणि output tokens एकत्र मोजले जातात. त्या चाचणीत 1,024 input tokens आणि 1,024 output tokens वापरले होते. त्यामुळे headline च्या जवळपास निम्मा भाग output असतो. हा फरक महत्त्वाचा आहे, कारण output हा धीमा भाग आहे. Prefill म्हणजे prompt वाचणे; त्यात सर्व input tokens एकाच pass मध्ये process केले जातात. Decode म्हणजे उत्तर लिहिणे; त्यात एका वेळी एक token तयार केला जातो. Total-throughput headline मध्ये कमी खर्चाचा भाग आणि जास्त खर्चाचा भाग एकत्र सरासरी काढली जाते.
आता पहिली row पाहा. तोच H200 एका वेळी एक request serve करताना 47 tok/s देतो. त्यामुळे त्याच hardware वर saturated आकडा चाळीसपटांपेक्षा जास्त आहे. हा फरक असतो, कारण एका decode step मध्ये GPU चा बराच वेळ memory ची वाट पाहण्यात जातो. Concurrent requests हा idle time वापरून घेतात. दुसरी row, 236 tok/s, त्याच model वरचा single H100 दाखवते. त्याला KV cache मुळे मर्यादा येते. KV cache म्हणजे key आणि value cache; serve केलेल्या conversation साठी per-request memory card वर ठेवली जाते. 70B model साठी 80 GB card वर कमी concurrent requests ठेवता येतात. त्यामुळे तिचे saturation कमी राहते.
Model बदलला किंवा input-to-output ratio बदलला, तर वरील प्रत्येक आकडा बदलतो. Published figures तुमच्या अपेक्षा ठरवतात; तुमचे budget नाही. Disk आणि network बाबतीत VPS चे benchmarking प्रामाणिकपणे करणे यालाही हाच नियम लागू होतो.
महत्त्वाच्या चार संख्या
- पहिल्या token पर्यंतचा वेळ, TTFT. विनंती पाठवल्यापासून पहिला output token मिळेपर्यंतचा विलंब. यात prefill time आणि queue time यांचा समावेश असतो. वापरकर्त्याला हा विलंब थेट जाणवतो.
- प्रति stream output tokens per second. उत्तर सुरू झाल्यानंतर ते किती वेगाने लिहिले जाते. साधारण 20 tok/s पेक्षा जास्त वेग बहुतेक लोकांच्या वाचनाच्या वेगापेक्षा आधीच जास्त असतो. त्यामुळे या वेगात आणखी वाढ केल्याचा फायदा कमी असतो.
- पूर्ण भाराखालील एकूण output throughput. सर्व concurrent streams मधील output च्या वेगांची बेरीज. ही capacity संख्या आहे. GPU चा खर्च योग्य ठरवणारी संख्याही हीच आहे.
- concurrency अंतर्गत p50 आणि p99 TTFT. p50 म्हणजे मधल्या विनंतीचे मूल्य. p99 म्हणजे 100 पैकी 99 विनंत्या ज्यापेक्षा कमी वेळात पूर्ण होतात ते मूल्य. Queueing चा परिणाम सर्वप्रथम p99 मध्ये दिसतो.
सर्व्हरवर कमी भार असताना पहिल्या दोन मापदंडांमध्ये सुधारणा होते. सर्व्हरवर जास्त भार असताना तिसऱ्या मापदंडात सुधारणा होते. हे मापदंड एकमेकांच्या विरुद्ध परिणाम करतात. म्हणून serving box चे वर्णन एका संख्येने करता येत नाही.
मापन करण्यापूर्वी input आणि output ची लांबी निश्चित करा
Throughput हा traffic च्या स्वरूपावर अवलंबून असतो. 4,000-token prompt आणि 50-token answer हे prefill-heavy काम असते. 200-token prompt आणि 2,000-token answer हे decode-heavy काम असते. त्याच server वर या दोन प्रकारांसाठी tokens per second चे परिणाम खूप वेगळे येतात. त्यामुळे एक ratio निवडा, नोंदवलेल्या प्रत्येक संख्येजवळ तो लिहा आणि वेगवेगळ्या ratios मधील परिणामांची तुलना करू नका. 1,024 input आणि 1,024 output हा योग्य default आहे, कारण अनेक vendors याच ratio वर परिणाम प्रकाशित करतात. तुमचा वास्तविक traffic माहीत असल्यास तोच वापरा.
Output ची लांबीही निश्चित ठेवा. एखादे model 60 tokens नंतर stop token गाठत असेल, तर त्याची run लहान असते आणि तिची full run सोबत तुलना करता येत नाही. अशा run मध्ये TTFT चा वाटा अधिक असतो. त्यामुळे benchmark ज्या पद्धतीने मोजतो त्यानुसार output throughput कमी दिसतो, जरी प्रत्येक request लवकर पूर्ण होत असली तरी. vLLM benchmark client मधील --ignore-eos flag प्रत्येक request कडून विनंती केलेली नेमकी संख्या generate करून घेतो. त्यामुळे दोन runs ची तुलना करता येते. कोणतेही flag पेक्षा model ची निवड या संख्यांवर अधिक परिणाम करते: एकाच VPS GPU वर Qwen 3 model बसवणे या निवडीच्या memory बाजूचे स्पष्टीकरण देते.
पहिले एका stream चे मापन करा
सर्वात सोप्या परिस्थितीपासून सुरुवात करा. ही sanity check आहे आणि कमाल मर्यादाही आहे. Ollama स्वतःचे timing दाखवते.
ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."वाचायची ओळ eval rate आहे. ती प्रति सेकंद output tokens दर्शवते. prompt eval rate हा prefill rate आहे आणि load duration हा model VRAM मध्ये लोड करण्यासाठी लागलेला वेळ आहे. cold start नंतरच्या पहिल्या call मध्ये load duration मोठे असते. त्यामुळे total duration दिशाभूल करणारे ठरते. command दोनदा चालवा आणि दुसरा result वाचा. Ollama idle model default ने पाच मिनिटांनंतर unload करते. त्यामुळे दोन runs मधील मोठ्या विश्रांतीनंतर पुन्हा cold case लागू होतो.
हेच fields API मधूनही मिळतात. त्यामुळे scripting करणे सोपे होते.
curl -s http://127.0.0.1:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Write 200 words about disk scheduling.",
"stream": false
}' | jq '{eval_count, eval_duration,
tok_s: (.eval_count / (.eval_duration / 1000000000))}'eval_duration nanoseconds मध्ये आहे. त्यामुळे त्याला 1,000,000,000 ने भागल्यास seconds मिळतात. tokens per second साठी Ollama च्या API documentation मध्येही नेमका हाच भागाकार सुचवला आहे. server अजून सुरू नसेल, तर VPS वर Ollama वापरून LLM self-host करणे या विभागात install आणि systemd unit दिले आहेत.
TTFT साठी streaming request आवश्यक आहे. curl त्याचा वेळ मोजू शकते.
curl -s -o /dev/null -N \
-w 'ttfb=%{time_starttransfer}s total=%{time_total}s\n' \
http://127.0.0.1:8000/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model":"Qwen/Qwen3-8B",
"messages":[{"role":"user","content":"Write 200 words about disk scheduling."}],
"stream":true,"max_tokens":256}'time_starttransfer हा response body मधील पहिला byte येण्याचा क्षण आहे. streaming chat completion मध्ये तो byte पहिल्या server-sent event चा भाग असतो. हा event पहिला content token किंवा त्याच्या अगोदर पाठवलेला role-only delta असू शकतो. त्यामुळे या मूल्याला एका event इतक्या फरकासह TTFT समजा. त्याच server वरील दोन runs ची तुलना करण्यासाठी हे पुरेसे अचूक आहे.
single-stream मोजमापांमुळे server दोन प्रकारे अधिक सक्षम दिसतो. TTFT ही सर्वात चांगली स्थिती असते, कारण तुमच्या आधी कोणतीही request queue मध्ये नसते. प्रति-stream rate देखील सर्वाधिक असतो, कारण संपूर्ण card एकाच request साठी वापरला जातो. server प्रत्यक्षात किती load हाताळू शकतो हे यापैकी कोणतेही मोजमाप सांगत नाही.
समांतर विनंत्यांची चाचणी कशी चालवायची?
एका sweep मध्ये एकच निश्चित workload वाढत्या concurrency वर चालवला जातो आणि प्रत्येक टप्प्यावर काय घडते ते नोंदवले जाते. यासाठी vLLM client देते. हा client OpenAI API वापरतो. त्यामुळे तो Ollama आणि OpenAI-compatible असलेल्या इतर कोणत्याही सेवेसोबतही कार्य करतो.
vllm bench serve \
--backend openai-chat \
--base-url http://127.0.0.1:8000 \
--endpoint /v1/chat/completions \
--model Qwen/Qwen3-8B \
--dataset-name random \
--random-input-len 1024 \
--random-output-len 1024 \
--ignore-eos \
--num-prompts 160 \
--max-concurrency 16 \
--percentile-metrics ttft,tpot,itl,e2el \
--metric-percentiles 50,99--max-concurrency एकाच वेळी सुरू असलेल्या requests ची कमाल संख्या ठरवते. याच variable वर sweep केला जातो. --num-prompts ही पाठवलेल्या requests ची एकूण संख्या आहे. स्थिर average मिळवण्यासाठी ती concurrency च्या सुमारे दहापट ठेवा. Summary मध्ये Output token throughput (tok/s): आणि Total token throughput (tok/s):, त्यानंतर Mean TTFT (ms):, Median TTFT (ms): आणि P99 TTFT (ms): हे Time to First Token heading अंतर्गत दिसतात.
त्या output मध्ये प्रत्येक stream साठी स्वतंत्र rate नसतो. मात्र तो एका division ने काढता येतो. Mean TPOT (ms): म्हणजे पहिल्या token नंतरच्या प्रत्येक output token साठी लागणारा mean time. त्यामुळे प्रत्येक token साठी 25 ms म्हणजे प्रत्येक stream साठी प्रति सेकंद 40 tokens. Output throughput ला concurrency ने भागल्यावरही तेच उत्तर मिळते.
आता ही प्रक्रिया loop मध्ये चालवा आणि प्रत्येक run जतन करा.
for C in 1 4 16 32 64 128; do
vllm bench serve \
--backend openai-chat \
--base-url http://127.0.0.1:8000 \
--endpoint /v1/chat/completions \
--model Qwen/Qwen3-8B \
--dataset-name random \
--random-input-len 1024 \
--random-output-len 1024 \
--ignore-eos \
--num-prompts $(( C * 10 )) \
--max-concurrency "$C" \
--percentile-metrics ttft,tpot,itl,e2el \
--metric-percentiles 50,99 \
--save-result --result-filename "sweep-c$C.json"
doneजतन केलेल्या JSON files वाचणे
प्रत्येक run एक file लिहितो. त्यामुळे सर्व files मधून आवश्यक fields एकाच वेळी काढा.
for f in sweep-c*.json; do
jq -r --arg f "$f" \
'[$f, .output_throughput, .total_token_throughput,
.median_ttft_ms, .p99_ttft_ms] | @tsv' "$f"
doneoutput_throughput म्हणजे प्रति सेकंद output tokens. total_token_throughput मध्ये input tokens देखील धरले जातात. त्यामुळे 1:1 ratio असताना ते जवळपास दुप्पट असते. p99_ttft_ms हे --metric-percentiles नसतानाही उपलब्ध असते, कारण त्या flag ची default value 99 आहे. Command मधील 50 मुळे p50_ttft_ms जोडले जाते. हे median_ttft_ms च्या शेजारी दिसते आणि --percentile-metrics मध्ये नमूद केलेल्या प्रत्येक metric ला लागू होते. .p90_ttft_ms सारखा मागवलेला नसलेला percentile विचारल्यास jq null print करते.
Concurrency sweep प्रत्यक्षात काय दाखवतो?
या तक्त्यामागील डेटा
[
{
"label": "1 stream",
"per_stream_tok_s": 92,
"total_tok_s": 92,
"ttft_p50_ms": 48,
"ttft_p99_ms": 61
},
{
"label": "4 streams",
"per_stream_tok_s": 88,
"total_tok_s": 352,
"ttft_p50_ms": 71,
"ttft_p99_ms": 96
},
{
"label": "16 streams",
"per_stream_tok_s": 71,
"total_tok_s": 1136,
"ttft_p50_ms": 152,
"ttft_p99_ms": 244
},
{
"label": "32 streams",
"per_stream_tok_s": 54,
"total_tok_s": 1728,
"ttft_p50_ms": 287,
"ttft_p99_ms": 498
},
{
"label": "64 streams",
"per_stream_tok_s": 34,
"total_tok_s": 2176,
"ttft_p50_ms": 611,
"ttft_p99_ms": 1240
},
{
"label": "128 streams",
"per_stream_tok_s": 18,
"total_tok_s": 2304,
"ttft_p50_ms": 1490,
"ttft_p99_ms": 3820
}
]त्या 6 ओळी, लहान भाडेतत्त्वावरील GPU बॉक्सवर sweep केल्यास कोणत्या स्वरूपाचा परिणाम मिळतो याचे उदाहरण आहेत. त्यांमध्ये व्यवहार्य परिमाणे दाखवली आहेत. त्या तुमच्या सर्व्हरचे मोजमाप नाहीत आणि vendor ने दिलेली आकडेवारीही नाही. वरील loop चालवा आणि त्या मूल्यांच्या जागी तुमची मूल्ये भरा.
हे स्वरूप समजून घ्या, कारण सर्वसाधारणपणे लागू होणारी गोष्ट म्हणजे हेच स्वरूप. एका stream वर संपूर्ण बॉक्स दर सेकंदाला 92 tokens तयार करतो आणि p99 TTFT 61 ms असतो. 128 streams वर एकूण throughput 2304 tokens प्रति सेकंदापर्यंत पोहोचतो, म्हणजे तो पंचवीस पट जास्त असतो. मात्र प्रत्येक स्वतंत्र stream चा वेग 18 tokens प्रति सेकंदापर्यंत कमी होतो आणि p99 TTFT 3820 ms पर्यंत वाढतो. Batching मुळे निष्क्रिय memory waits चे उपयुक्त कामात रूपांतर होते, म्हणून एकूण throughput वाढतो. तोच compute आता अनेक stream मध्ये वाटला जातो, म्हणून प्रत्येक stream चा वेग कमी होतो.
शेवटचे doubling महत्त्वाचा संकेत देते. 64 वरून 128 streams केल्यावर एकूण throughput मध्ये सहा टक्क्यांपेक्षा कमी वाढ होते, परंतु p99 TTFT साधारण तिप्पट होतो. याचा अर्थ requests चालण्याऐवजी queue मध्ये थांबत आहेत. याचे कारण KV cache पूर्ण झालेला असू शकतो किंवा server ने vLLM च्या max_num_seqs सारखी scheduling मर्यादा गाठलेली असू शकते. उपयुक्त operating point त्याआधी आहे: 32 streams वर बॉक्स अजूनही दर सेकंदाला 1728 tokens परत करतो, म्हणजे त्याच्या peak च्या 75 percent इतका throughput देतो. त्या वेळी प्रत्येक stream चा वेग 54 tokens प्रति सेकंद आणि p99 TTFT 498 ms असतो. हा बिंदू तुमची capacity म्हणून नोंदवा. Curve वरील peak ही अशी संख्या आहे जिच्या आधारावर तुम्ही users ना सेवा देऊ शकत नाही.
Ollama आणि vLLM एकच गोष्ट मोजत नाहीत
ही sweep default Ollama server विरुद्ध चालवल्यास एकूण आकडा फारसा बदलणार नाही. OLLAMA_NUM_PARALLEL ची default value 1 आहे. त्यामुळे एका वेळी एकच request चालते आणि उर्वरित requests प्रतीक्षा करतात. या queue मुळे p99 TTFT वाढतो, तर एकूण output जवळपास स्थिर राहतो. कोणतेही मोजमाप करण्यापूर्वी ही value वाढवा.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=8"sudo systemctl restart ollama वापरून restart करा आणि model अजूनही उपलब्ध VRAM मध्ये मावतो का ते तपासा. प्रत्येक parallel slot ला context window मधील स्वतंत्र हिस्सा मिळतो. त्यामुळे Ollama च्या documentation नुसार, 4 parallel requests साठी 2K context केल्यास 8K वाटप केले जाते. Slot count पुरेसा वाढवल्यास model VRAM च्या बाहेर जाऊ शकतो. ollama ps तपासा: PROCESSOR column मध्ये 48%/52% CPU/GPU सारखी value दिसत असल्यास model चा काही भाग CPU वर चालत आहे. अशा वेळी concurrency वाढवल्यावर throughput वाढण्याऐवजी कमी होईल. Parallel slots संपल्यानंतर requests OLLAMA_MAX_QUEUE पर्यंत queue होतात. Default value 512 आहे. त्यानंतर server 503 उत्तर देतो.
vLLM continuous batching वापरतो. त्यामुळे slots मोकळे होताच तो नवीन requests चालू batch मध्ये समाविष्ट करतो. काहीतरी संसाधन संपेपर्यंत त्याची कामगिरी वाढत राहते. सहसा हे KV cache असते. मात्र max_num_seqs सारखी configured cap किंवा CPU scheduling overhead यामुळे ती वाढ त्यापूर्वीच थांबू शकते. Ollama एका model साठी, एका machine वर आणि कमी setup cost मध्ये काम करण्यासाठी optimize केलेले आहे. त्यामुळे एकाच sweep साठी दोन्ही engines वेगवेगळी उत्तरे देतात. हाच Ollama आणि vLLM यांची serving engines म्हणून तुलना याचा मुख्य विषय आहे. प्रत्येक आकडा कोणत्या engine ने आणि कोणत्या version ने तयार केला हे नोंदवा.
चुकीची गोष्ट मोजण्याचे पाच मार्ग
- क्लायंट खूप दूर आहे. इंटरनेटवरून तुमच्या laptop वरून benchmark चालवल्यास प्रत्येक TTFT मध्ये तुमचा round trip time जोडला जातो. त्यामुळे तुम्ही प्रत्यक्षात तुमचे home connection मोजत असता. क्लायंट server च्या त्याच region मध्ये चालवा.
- model cold होता. पहिल्या request साठी weights load करण्याचा वेळ लागतो. vLLM मध्ये graph capture चा वेळही लागू शकतो. एक warmup batch पाठवा आणि त्याचा result टाकून द्या.
- Prefix caching ने तुमच्यासाठी उत्तर दिले. vLLM मध्ये automatic prefix caching default ने enabled असते. त्यामुळे तोच prompt वारंवार पाठवल्यास prefill ऐवजी cache मोजला जातो आणि TTFT चे मूल्य वास्तविक मूल्याच्या लहान भागाइतकेच राहते.
--dataset-name randomही समस्या टाळते, कारण प्रत्येक prompt वेगळा असतो. याची खात्री करण्यासाठी server--no-enable-prefix-cachingसह सुरू करा. - outputs लहान होते. 32-token उत्तरांमध्ये प्रत्येक request वर TTFT चा प्रभाव जास्त असतो. त्यामुळे तुमचे tokens per second मोजमाप प्रत्यक्षात prefill चे वर्णन करते. वास्तविक output length सह
--ignore-eosवापरा. - तुम्ही फक्त concurrency 1 नोंदवली. यामुळे sheet वर सर्वात अनुकूल TTFT मिळतो. तुमच्या वास्तविक requests कधीही overlap होत नसतील तरच हा योग्य cost input आहे. requests overlap होत असतील, तर cost हा तुमच्या traffic मुळे निर्माण होणाऱ्या concurrency वर तुम्ही टिकवून ठेवलेल्या throughput वर अवलंबून असतो. त्यामुळे त्या concurrency वरही मोजमाप करा.
मोजलेली संख्या वापरून निर्णय घ्या
तुमच्या प्रत्यक्ष traffic मध्ये ज्या concurrency पर्यंत पोहोचते, त्या concurrency वर sweep ने दाखवलेला output throughput घ्या आणि त्याची प्रति-token pricing शी तुलना करा. Requests पुरेशा प्रमाणात एकमेकांवर overlap होऊन batch पूर्ण भरत असेल, तरच हा saturated figure लागू होतो. एका वेळी एकच request पाठवणाऱ्या workload साठी single-stream rate वापरावा लागतो. प्रत्येक output token सोबत येणाऱ्या input tokens ची किंमत धरल्यानंतर break-even एका division ने काढता येतो:
cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600DigitalOcean च्या July 2026 मधील prices वापरून हे मोजू. त्यांच्या H200 dedicated inference endpoint ची किंमत प्रति तास $4.47 होती. Serverless Llama 3.3 70B साठी input ची किंमत प्रति million tokens $0.65 आणि output ची किंमत प्रति million tokens $0.65 होती. वर वापरलेल्या 1:1 ratio मध्ये प्रत्येक million output tokens सोबत एक million input tokens येतात. त्यामुळे प्रभावी किंमत प्रति million output tokens $1.30 होते. म्हणून 4.47 ला 1.30 ने भागल्यास प्रति तास सुमारे 3.44 million output tokens मिळतात. 3,600 seconds ने भागल्यावर प्रति सेकंद सुमारे 955 output tokens मिळतात. Input आणि output एकत्र मोजल्यास हे सुमारे 1,910 tokens per second होते. Prices त्यांच्या आहेत. Division आपली आहे. 25 October 2026 रोजी तपासले असता H200 endpoint ची किंमत अजूनही प्रति तास $4.47 होती. मात्र DigitalOcean ने 18 August 2026 रोजी serverless Llama 3.3 70B deprecated केले आणि users ना Llama 4 Maverick कडे निर्देशित केले. त्याची किंमत प्रति million input tokens $0.25 आणि प्रति million output tokens $0.87 अशी नमूद आहे. हा वेगळा model आहे. त्यामुळे तुलना अर्थपूर्ण होण्यापूर्वी त्यासाठी स्वतंत्र sweep आवश्यक आहे.
या निर्णयासाठी महत्त्वाचा शब्द sustained आहे. Saturation स्थितीत दोन तास दररोज प्रति सेकंद 955 output tokens मिळणे म्हणजे sustained प्रति सेकंद 955 output tokens नव्हे. कारण उर्वरित बावीस तासांची किंमतही तुम्हाला द्यावी लागते. GPU Droplet म्हणून card rent केल्याने ही मर्यादा कमी होत नाही. 25 October 2026 रोजी DigitalOcean च्या Droplet pricing मध्ये H200 ची on-demand किंमत प्रति तास $4.47 होती. ही endpoint इतकीच होती. त्यांच्या सर्वात स्वस्त NVIDIA Droplets पैकी RTX 4000 ची किंमत प्रति तास $0.76 आणि L40S किंवा RTX 6000 ची किंमत प्रति तास $1.57 होती. मात्र FP8 मध्ये 70B model ठेवण्यासाठी ही cards पुरेशी मोठी नाहीत. त्यामुळे वरील आकडे वापरल्यास, 2,036 output tokens per second वर saturate होणाऱ्या H200 ने तुम्ही पैसे देत असलेल्या प्रत्येक तासात त्या peak च्या सरासरी सुमारे 47 percent इतका throughput साधला पाहिजे. तेव्हाच input आणि output साठी प्रति million tokens $0.65 या किंमतीशी break-even होईल. त्याखाली per-token pricing अधिक स्वस्त ठरते. Self-hosting चा खर्च सहसा slow tokens मुळे नव्हे, तर idle GPU hours मुळे वाढतो.
म्हणून तुमच्या निर्णयासाठी दोन inputs आहेत. Sweep तुम्हाला ceiling देते. तुमचा traffic pattern त्या ceiling पैकी प्रत्यक्षात मिळणारा fraction देतो. या दोन्हींचा गुणाकार करा. त्यानंतर GPU VPS ची per-token API break-even शी तुलना येथे मिळालेला result वापरा आणि तुमच्या volume साठी योग्य उत्तर वाचा.
FAQ
self-hosted LLM साठी tokens per second चे चांगले प्रमाण किती?
याचे दोन उत्तर आहेत, कारण हे मेट्रिक दोन वेगवेगळी कामे करते. एक व्यक्ती output वाचत असेल, तर प्रत्येक stream साठी साधारण 20 output tokens per second पेक्षा जास्त वेग वाचनाच्या वेगापेक्षा अधिक असतो. त्यामुळे त्यापेक्षा जास्त वेगाचा उपयोग होत नाही. खर्चाच्या दृष्टीने, तुमच्या प्रत्यक्ष load अंतर्गत सातत्याने राखता येणारा एकूण output throughput महत्त्वाचा असतो. तुमचा break-even point पार करणारा कोणताही throughput चांगला मानता येतो. input आणि output दोन्हीसाठी प्रति million tokens $0.65 आणि प्रति तास $4.47 खर्च असलेल्या server वर, July 2026 मधील किमती आणि 1:1 ratio गृहीत धरल्यास, ही किमान पातळी सातत्याने सुमारे 955 output tokens per second असते. मोठ्या model वर एकच stream ही पातळी गाठत नाही. म्हणून batching आवश्यक असते.
concurrent requests वाढवल्यावर माझा Ollama throughput स्थिर का राहतो?
OLLAMA_NUM_PARALLEL चे default मूल्य 1 आहे. त्यामुळे server प्रत्येक model साठी एका वेळी एकच request चालवतो आणि उर्वरित requests queue मध्ये ठेवतो. OLLAMA_MAX_QUEUE पर्यंत (default मूल्य 512) queue भरल्यानंतर server 503 परत करतो. p99 TTFT वाढत असताना एकूण output स्थिर राहतो. हे GPU व्यस्त असल्याऐवजी queue तयार झाल्याचे लक्षण आहे. systemd drop-in मध्ये हे variable सेट करून सेवा restart करा. त्यानंतर ollama ps तपासा, कारण प्रत्येक parallel slot मुळे allocated context वाढते आणि model चा काही भाग CPU वर जाऊ शकतो.
time to first token मोजावे की tokens per second?
दोन्ही मोजा, कारण load वाढल्यावर हे दोन्ही विरुद्ध दिशेने बदलतात. वापरकर्त्याला जाणवणारा घटक TTFT आहे. तुमच्या invoice वर परिणाम करणारा घटक म्हणजे saturated output throughput. प्रत्येक concurrency step वर p50 आणि p99 TTFT नोंदवा. त्यानंतर p99 TTFT तुम्हाला अजून स्वीकारार्ह वाटत असेल अशी सर्वाधिक concurrency निवडा. त्या बिंदूवरील throughput तुमची capacity म्हणून नोंदवा. curve च्या सर्वोच्च बिंदूवरील कमाल throughput वापरू नका.
tokens per second चे जास्त प्रमाण नेहमीच प्रति token कमी खर्च दर्शवते का?
नाही. प्रति token खर्च म्हणजे त्या तासात server ने प्रत्यक्ष तयार केलेल्या tokens ने प्रति तासाची किंमत भागलेली रक्कम. त्यामुळे दिवसभरातील बहुतांश वेळ idle असलेला वेगवान server सुद्धा प्रति token जास्त खर्चाचा ठरू शकतो. हा खर्च peak speed नव्हे, तर utilisation ठरवते. Units कडेही लक्ष द्या. उद्धृत केलेला total token throughput input tokens मोजत असेल, तर 1:1 input-to-output ratio मध्ये तो output rate च्या जवळपास दुप्पट असतो. तुम्ही ज्या API शी तुलना करत आहात ते input tokens आणि output tokens दोन्हीसाठी शुल्क आकारत असल्यास, तुलना करण्यापूर्वी दोन्ही भागांच्या किमती मोजा.