مقامی LLM میں tokens per second کیسے ناپیں
GPU کرائے پر لینا کب فی token ادائیگی سے سستا ہوتا ہے؟ concurrency sweep سے tokens per second درست ناپیں، پھر حقیقی throughput کے مطابق فیصلہ کریں۔
یہ فیصلہ tokens per second کرتے ہیں کہ GPU کی لاگت فائدہ مند ہے یا نہیں
tokens per second وہ شرح ہے جس پر آپ کا سرور output text تیار کرتا ہے۔ یہی عدد طے کرتا ہے کہ GPU کرائے پر لینا، API کو فی token ادائیگی کرنے سے سستا ہے یا نہیں۔ GPU box کے لیے فی گھنٹہ بل ادا کرنا ہوتا ہے، چاہے وہ مصروف ہو یا idle۔ hosted API کے اخراجات tokens کی تعداد کے مطابق ہوتے ہیں۔ اس لیے GPU اسی وقت فائدہ مند ہوتا ہے جب آپ جن زیادہ تر گھنٹوں کی ادائیگی کرتے ہیں، ان میں output rate کافی زیادہ رہے۔
اس کا مطلب ہے کہ آپ کو حقیقی measurement درکار ہے، نہ کہ کہیں پڑھی ہوئی کوئی figure۔ یہ صفحہ ریکارڈ کیے جانے کے قابل چار numbers کی وضاحت کرتا ہے، پھر وہ commands دیتا ہے جو یہ numbers حاصل کرتی ہیں، اور آخر میں وہ arithmetic دکھاتا ہے جس سے فیصلہ کیا جا سکتا ہے۔
شائع کردہ tokens per second کا عدد آپ کا عدد کیوں نہیں ہوتا
DigitalOcean نے July 2026 میں vLLM کے تحت FP8 (8-bit floating point) میں ایک NVIDIA H200 پر llama3.3-70b-instruct کے لیے 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 کی نچلی حد ہیں، اس لیے انہیں minimum سمجھیں۔ اس chart میں کوئی عدد ہم نے خود measure نہیں کیا۔
آخری دو rows سے شروع کریں۔ headline 4,071.6 tok/s ہے، جبکہ صرف output کی rate 2,036 tok/s ہے۔ headline میں input اور output tokens کو اکٹھا شمار کیا گیا ہے۔ اس test میں 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 دیتا ہے، اس لیے saturated figure یکساں hardware پر چالیس گنا سے زیادہ بلند ہے۔ یہ فرق اس لیے ہوتا ہے کہ ایک decode step کے دوران GPU زیادہ تر وقت memory کا انتظار کرتا ہے، جبکہ concurrent requests اس خالی وقت کو استعمال کر لیتی ہیں۔ دوسری row، 236 tok/s، اسی model پر ایک H100 کی rate ہے، جسے KV cache، یعنی key اور value cache، محدود کرتی ہے۔ یہ ہر served conversation کے لیے card پر رکھی جانے والی per-request memory ہے۔ 80 GB card 70B model کے لیے کم concurrent requests رکھ سکتی ہے، اس لیے یہ کم throughput پر saturate ہوتی ہے۔
Model تبدیل کریں یا input اور output کا ratio تبدیل کریں تو اوپر موجود ہر عدد بدل جائے گا۔ شائع کردہ اعداد آپ کی توقعات متعین کرتے ہیں، budget نہیں۔ یہی اصول disk اور network پر VPS کی دیانت دارانہ benchmarking پر بھی لاگو ہوتا ہے۔
اہم چار اعداد
- پہلے token تک وقت، TTFT۔ درخواست بھیجنے اور پہلے output token کے موصول ہونے کے درمیان تاخیر۔ اس میں prefill time اور queue time دونوں شامل ہوتے ہیں۔ صارف اسے براہِ راست محسوس کرتا ہے۔
- ہر stream کے لیے فی سیکنڈ output tokens۔ جواب شروع ہونے کے بعد ایک جواب لکھنے کی رفتار۔ تقریباً 20 tok/s سے زیادہ رفتار پر یہ پہلے ہی زیادہ تر لوگوں کی پڑھنے کی رفتار سے تیز ہوتی ہے، اس لیے یہاں اضافی رفتار کا فائدہ کم ہوتا ہے۔
- مصروف حالت میں مجموعی output throughput۔ server کے مکمل load پر تمام concurrent streams کی مجموعی رفتار۔ یہ capacity کا عدد ہے، اور اسی سے GPU کا خرچ پورا ہوتا ہے۔
- concurrency کے دوران p50 اور p99 TTFT۔ p50 درمیانی درخواست کی قدر ہے۔ p99 وہ قدر ہے جس سے 100 میں سے 99 درخواستیں کم وقت میں مکمل ہوتی ہیں۔ Queueing کا اثر ہمیشہ پہلے p99 میں ظاہر ہوتا ہے۔
پہلے دو اعداد server کے کم مصروف ہونے پر بہتر ہوتے ہیں۔ تیسرا server کے مصروف ہونے پر بہتر ہوتا ہے۔ یہ ایک دوسرے کے خلاف اثر ڈالتے ہیں، اسی لیے کوئی ایک عدد serving box کی مکمل کارکردگی بیان نہیں کرتا۔
پیمائش سے پہلے input اور output کی لمبائیاں طے کریں
Throughput ٹریفک کی ساخت پر منحصر ہوتا ہے۔ 4,000-token prompt اور 50-token جواب والا کام prefill-heavy ہوتا ہے۔ 200-token prompt اور 2,000-token جواب والا کام decode-heavy ہوتا ہے۔ ایک ہی server ان دونوں صورتوں میں tokens per second کی بہت مختلف قدر دکھاتا ہے۔ اس لیے ایک ہی ratio منتخب کریں، ریکارڈ کیے گئے ہر عدد کے ساتھ اسے لکھیں، اور مختلف ratios کے نتائج کا کبھی موازنہ نہ کریں۔ 1,024 input اور 1,024 output ایک مناسب default ہے، کیونکہ کئی vendors اسی ratio پر اعداد شائع کرتے ہیں۔ اگر آپ کو اپنی حقیقی ٹریفک کا علم ہے تو وہی ratio استعمال کریں۔
Output کی لمبائی بھی مقرر کریں۔ جو model 60 tokens کے بعد stop token تک پہنچ جاتا ہے، اس کا run مختصر ہوتا ہے اور اس کا موازنہ مکمل run سے نہیں کیا جا سکتا۔ اس صورت میں TTFT کا حصہ زیادہ ہو جاتا ہے، جس سے benchmark کے مطابق output throughput کم دکھائی دیتا ہے، اگرچہ ہر request جلد مکمل ہو جاتی ہے۔ vLLM benchmark client میں --ignore-eos flag ہر request کو بالکل مقررہ تعداد generate کرنے پر مجبور کرتا ہے، اس لیے دونوں runs کا موازنہ برقرار رہتا ہے۔ Model کا انتخاب ان اعداد کو کسی بھی flag سے زیادہ بدلتا ہے: ایک single 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 میں load کرنے میں صرف ہونے والا وقت ہے۔ cold start کے بعد پہلی call میں load duration بڑا ہوتا ہے، اس لیے total duration گمراہ کن ہوتا ہے۔ command دو بار چلائیں اور دوسری result پڑھیں۔ Ollama بطور default idle model کو پانچ منٹ بعد 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 کے لیے یہی division Ollama کی اپنی API documentation میں تجویز کی گئی ہے۔ اگر server ابھی up نہیں ہے تو VPS پر Ollama کے ساتھ LLM کی self-hosting میں installation اور 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۔ اس لیے اس value کو تقریباً ایک event کے فرق کے ساتھ TTFT سمجھیں۔ ایک ہی server پر دو runs کا موازنہ کرنے کے لیے یہ کافی درست ہے۔
Single-stream numbers server کی صلاحیت کو دو بار زیادہ ظاہر کرتے ہیں۔ TTFT اس کی ممکنہ بہترین حالت ہوتی ہے، کیونکہ آپ سے پہلے کوئی request queue میں نہیں ہوتی۔ فی stream rate بھی ممکنہ بہترین حالت ہوتی ہے، کیونکہ پوری card ایک ہی request serve کر رہی ہوتی ہے۔ ان دونوں میں سے کوئی بھی یہ نہیں بتاتا کہ server حقیقت میں کتنا load سنبھال سکتا ہے۔
آپ concurrency sweep کیسے چلاتے ہیں؟
Sweep ایک مقررہ workload کو بڑھتی ہوئی concurrency پر چلاتا ہے اور ہر مرحلے پر ہونے والے نتائج ریکارڈ کرتا ہے۔ vLLM اس کام کے لیے 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 ہیں، اس لیے مستحکم اوسط حاصل کرنے کے لیے اسے 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 کے لیے اوسط وقت ہے، اس لیے فی token 25 ms کا مطلب ہر stream کے لیے 40 tokens per second ہے۔ 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 لکھتا ہے، اس لیے مطلوبہ fields تمام files سے ایک ساتھ نکالیں۔
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 per second ہے۔ 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 کو ملتا ہے۔ اگر آپ ایسا percentile طلب کریں جس کی درخواست نہیں کی تھی، مثلاً .p90_ttft_ms، تو jq null print کرتا ہے۔
کنکرنسی 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 rows اس شکل کی مثال ہیں جو ایک چھوٹے کرائے پر دستیاب GPU box پر sweep سے حاصل ہوتی ہے، اور ان کی مقداریں قابلِ قبول حدود میں ہیں۔ یہ آپ کے server کی measurement نہیں ہیں، نہ ہی vendor کا فراہم کردہ عدد ہیں۔ اوپر دیا گیا loop چلائیں اور ان کی جگہ اپنی values رکھیں۔
اس شکل کو سمجھیں، کیونکہ عمومی طور پر قابلِ اطلاق چیز یہی شکل ہے۔ ایک stream پر پورا box فی second 92 tokens پیدا کرتا ہے، جبکہ p99 TTFT 61 ms ہے۔ 128 streams streams پر مجموعی throughput 2304 tokens per second تک پہنچ جاتا ہے، جو 25 گنا زیادہ ہے، لیکن ہر individual stream کی رفتار کم ہو کر 18 tokens per second رہ جاتی ہے اور p99 TTFT 3820 ms تک پہنچ جاتا ہے۔ مجموعی throughput اس لیے بڑھتا ہے کہ batching، غیر استعمال شدہ memory waits کو مفید کام میں بدل دیتی ہے۔ ہر stream کی رفتار اس لیے کم ہوتی ہے کہ اب وہی compute مشترکہ طور پر استعمال ہو رہا ہے۔
آخری doubling اہم اشارہ ہے۔ 64 سے 128 streams تک جانے سے مجموعی throughput میں 6 فیصد سے بھی کم اضافہ ہوتا ہے، جبکہ p99 TTFT تقریباً 3 گنا بڑھ جاتا ہے۔ اس کا مطلب ہے کہ requests execute ہونے کے بجائے queue میں جمع ہو رہی ہیں۔ وجہ یا تو KV cache کا بھر جانا ہے، یا server نے scheduling cap تک پہنچ گیا ہے، جیسے vLLM کا max_num_seqs۔ مفید operating point اس سے پہلے آتا ہے: 32 streams پر box اب بھی 1728 tokens per second واپس کرتا ہے، جو peak کا 75 فیصد ہے، جبکہ فی stream رفتار 54 tokens per second اور p99 TTFT 498 ms ہے۔ اسی point کو اپنی capacity کے طور پر report کریں۔ curve کا peak ایسی تعداد ہے جس پر آپ users کو service نہیں دے سکتے۔
Ollama اور vLLM ایک ہی چیز کی پیمائش نہیں کرتے
یہ sweep ایک default Ollama server کے خلاف چلائیں تو total بمشکل بدلے گا۔ OLLAMA_NUM_PARALLEL کی default value 1 ہے، اس لیے ایک request چلتی ہے جبکہ باقی انتظار کرتی ہیں، اور یہی queue p99 TTFT کو بڑھاتی ہے جبکہ total output تقریباً یکساں رہتا ہے۔ کسی بھی پیمائش سے پہلے اسے بڑھائیں۔
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=8"sudo systemctl restart ollama کے ساتھ restart کریں، پھر تصدیق کریں کہ model اب بھی fit ہو رہا ہے۔ ہر parallel slot کو context window کا اپنا حصہ ملتا ہے، اس لیے Ollama کی documentation کے مطابق 4 parallel requests کے ساتھ 2K context، 8K allocate کرتا ہے۔ slot count اتنا بڑھا دیں کہ model VRAM سے باہر نکل جائے، تو model کا کچھ حصہ CPU پر چلا جاتا ہے۔ 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 میں شامل کرتا ہے۔ اس کی curve اس وقت تک بڑھتی رہتی ہے جب تک کوئی resource ختم نہ ہو جائے۔ عموماً یہ KV cache ہوتا ہے، اگرچہ max_num_seqs جیسی configured cap یا CPU scheduling overhead اس curve کو اس سے پہلے بھی ہموار کر سکتی ہے۔ Ollama ایک model، ایک machine اور کم setup cost کے لیے optimise ہوتا ہے۔ اس لیے دونوں engines ایک ہی sweep پر مختلف نتائج دیتے ہیں، اور یہی Ollama اور vLLM کا serving engines کے طور پر تقابل کا اصل موضوع ہے۔ ہر number کے ساتھ درج کریں کہ اسے کس engine اور کس version نے produce کیا۔
غلط چیز کی پیمائش کرنے کے پانچ طریقے
- کلائنٹ بہت دور ہے۔ انٹرنیٹ کے ذریعے اپنے laptop سے benchmark چلانے پر ہر TTFT میں آپ کا round trip شامل ہو جاتا ہے، اس لیے آپ دراصل اپنے گھر کے connection کی پیمائش کرتے ہیں۔ کلائنٹ کو server کے اسی region میں چلائیں۔
- model cold state میں تھا۔ پہلی 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کے ساتھ start کریں۔ - outputs مختصر تھے۔ 32-token answers کے ساتھ ہر request میں TTFT غالب آ جاتا ہے، اور آپ کی tokens per second قدر دراصل prefill بیان کر رہی ہوتی ہے۔ حقیقت پسندانہ output length کے ساتھ
--ignore-eosاستعمال کریں۔ - آپ نے صرف concurrency 1 رپورٹ کی۔ اس سے sheet پر سب سے سازگار TTFT ملتا ہے، اور یہ cost کے لیے درست input صرف اسی صورت میں ہے جب آپ کی حقیقی requests کبھی overlap نہ کریں۔ اگر وہ overlap کرتی ہیں تو cost کا انحصار اس throughput پر ہوتا ہے جسے آپ اپنی traffic سے پیدا ہونے والی concurrency پر برقرار رکھتے ہیں، اس لیے وہاں بھی پیمائش کریں۔
اپنی پیمائش کو فیصلے میں کیسے تبدیل کریں
Sweep جس concurrency پر آپ کی حقیقی traffic پہنچتی ہے، وہاں دکھائی دینے والا output throughput لیں اور اسے per-token pricing کے ساتھ compare کریں۔ یہ صرف اسی صورت saturated figure ہے جب کافی requests بیک وقت چل رہی ہوں اور batch مکمل بھرا رہے؛ جو workload ایک وقت میں صرف ایک request بھیجتا ہے، اسے single-stream rate استعمال کرنی ہوگی۔ Break-even ایک division سے معلوم ہو جاتا ہے، بشرطیکہ ہر output token کے ساتھ آنے والے input tokens کی قیمت بھی شامل کریں:
cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600اسے DigitalOcean کی July 2026 کی prices کے ساتھ حساب کریں۔ ان کا H200 dedicated inference endpoint $4.47 فی گھنٹہ تھا، جبکہ serverless Llama 3.3 70B کے لیے input کی قیمت $0.65 فی million tokens اور output کی قیمت بھی $0.65 فی million tokens تھی۔ اوپر استعمال کیے گئے 1:1 ratio پر ہر million output tokens کے ساتھ ایک million input tokens بھی آتے ہیں، اس لیے مؤثر قیمت $1.30 فی million output tokens بنتی ہے۔ لہٰذا 4.47 کو 1.30 سے تقسیم کرنے پر تقریباً 3.44 million output tokens فی گھنٹہ آتے ہیں، اور 3,600 seconds سے تقسیم کرنے پر تقریباً 955 output tokens per second، یا 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 کر دیا اور صارفین کو Llama 4 Maverick کی طرف بھیجا، جس کی فہرست میں input کے لیے $0.25 فی million tokens اور output کے لیے $0.87 فی million tokens درج ہیں۔ یہ مختلف model ہے، اس لیے comparison بامعنی ہونے سے پہلے اسے اپنا sweep درکار ہے۔
اس فیصلے کا بنیادی لفظ sustained ہے۔ Saturation پر دو گھنٹے روزانہ 955 output tokens per second حاصل کرنا sustained 955 output tokens per second نہیں ہے، کیونکہ باقی بائیس گھنٹوں کی ادائیگی بھی آپ ہی کرتے ہیں۔ Card کو GPU Droplet کے طور پر 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 رکھنے کے لیے بہت چھوٹی ہیں۔ اس لیے اوپر کے اعداد کے مطابق، 2,036 output tokens per second پر saturate ہونے والے H200 کو ہر ادا کردہ گھنٹے کے دوران اپنی peak کا اوسط تقریباً 47 percent برقرار رکھنا ہوگا، صرف اس لیے کہ input اور output دونوں کے لیے $0.65 فی million tokens کی قیمت کے برابر ہو سکے۔ اس سے کم utilization پر per-token price بہتر رہتی ہے۔ عموماً self-hosting کو سست tokens نہیں بلکہ idle GPU hours نقصان پہنچاتے ہیں۔
لہٰذا آپ کے فیصلے کے لیے دو inputs ہیں۔ Sweep آپ کو ceiling دیتا ہے۔ آپ کی traffic pattern بتاتی ہے کہ اس ceiling کا کتنا حصہ حقیقت میں حاصل ہوتا ہے۔ دونوں کو multiply کریں، پھر نتیجے کو GPU VPS اور per-token API break-even کے تقابل پر لے جائیں اور اپنی volume کے لیے جواب معلوم کریں۔
FAQ
self-hosted LLM کے لیے tokens per second کی اچھی شرح کیا ہے؟
اس کے دو جواب ہیں، کیونکہ یہ پیمانہ دو مختلف کام انجام دیتا ہے۔ اگر ایک شخص output پڑھ رہا ہو تو ہر stream پر تقریباً 20 output tokens per second سے زیادہ رفتار پہلے ہی پڑھنے کی رفتار سے تیز ہے، اس لیے اس سے زیادہ رفتار فائدہ نہیں دیتی۔ لاگت کے لیے اہم عدد وہ total output throughput ہے جسے آپ اپنے حقیقی load کے دوران برقرار رکھ سکتے ہیں، اور اچھی شرح وہ ہے جو break-even حد عبور کر دے۔ $0.65 per million tokens، یعنی input اور output دونوں، اور $4.47 per hour لاگت والے server کے مقابلے میں، July 2026 کی قیمتوں اور 1:1 ratio پر یہ حد تقریباً 955 output tokens per second sustained بنتی ہے۔ ایک بڑے model پر ایک stream کبھی اس حد تک نہیں پہنچتی، اسی لیے batching استعمال کی جاتی ہے۔
concurrent requests شامل کرنے پر میری Ollama throughput یکساں کیوں رہتی ہے؟
OLLAMA_NUM_PARALLEL کی default قدر 1 ہے، اس لیے server ہر model کے لیے ایک وقت میں ایک request چلاتا ہے اور باقی requests کو queue میں رکھتا ہے؛ OLLAMA_MAX_QUEUE تک، جو default طور پر 512 ہے، پہنچنے کے بعد 503 واپس کرتا ہے۔ Total output یکساں رہتا ہے، جبکہ p99 TTFT بڑھتا ہے۔ یہ مصروف GPU کے بجائے queue کی علامت ہے۔ systemd drop-in میں یہ variable set کر کے service restart کریں، پھر ollama ps چیک کریں، کیونکہ ہر parallel slot مختص context کو کئی گنا بڑھاتا ہے اور model کے کچھ حصے CPU پر منتقل کر سکتا ہے۔
مجھے time to first token ناپنا چاہیے یا tokens per second؟
دونوں ناپیں، کیونکہ load بڑھنے پر یہ مخالف سمتوں میں تبدیل ہوتے ہیں۔ TTFT وہ وقت ہے جسے user محسوس کرتا ہے، جبکہ saturated output throughput آپ کے invoice پر اثر انداز ہوتا ہے۔ ہر concurrency step پر p50 اور p99 TTFT record کریں، پھر وہ highest concurrency منتخب کریں جہاں p99 TTFT اب بھی آپ کے لیے قابل قبول ہو۔ اسی مقام کی throughput کو اپنی capacity قرار دیں، curve کے بلند ترین مقام سے حاصل ہونے والی maximum throughput کو نہیں۔
کیا tokens per second کی زیادہ شرح ہمیشہ per-token لاگت کم ہونے کا مطلب ہے؟
نہیں۔ Cost per token اس hourly price کو اس تعداد پر تقسیم کرنے سے معلوم ہوتی ہے جو server نے اس گھنٹے میں حقیقتاً produce کیے ہوں۔ اس لیے دن کے زیادہ حصے میں idle رہنے والے تیز server کی cost per token اب بھی زیادہ ہو سکتی ہے۔ اس کا فیصلہ utilisation کرتی ہے، peak speed نہیں۔ Units بھی دیکھیں: quoted total token throughput میں input tokens شامل ہوتے ہیں، اس لیے 1:1 input-to-output ratio پر یہ output rate سے تقریباً دو گنا کے قریب ہوتی ہے۔ اگر جس API سے آپ موازنہ کر رہے ہیں وہ input tokens کے ساتھ output tokens کی بھی billing کرتی ہے تو موازنے سے پہلے دونوں حصوں کی قیمت شامل کریں۔