Jinsi ya kupima tokens per second kwenye LLM yako
Kukodisha GPU kunalipa tu ikiwa throughput inavuka kiwango fulani. Jifunze kupima tokens per second kwa usahihi kupitia concurrency sweep ili kuepuka gharama za ziada.
Kwa nini tokens per second huamua kama GPU inalipa
Tokens per second ni kasi ambayo seva yako inazalisha matini ya pato, na ndiyo namba inayoamua kama kukodisha GPU ni nafuu kuliko kulipia API kwa kila token. Sanduku la GPU hutoza ada kwa saa bila kujali kama linafanya kazi au limekaa tu. API inayohudumiwa hutoza ada kwa kila token. Kwa hivyo, GPU inafaa tu ikiwa utadumisha kasi ya juu ya pato katika saa nyingi unazolipia.
Hii inamaanisha unahitaji kipimo, si takwimu uliyosoma mahali fulani. Ukurasa huu unafafanua namba nne zinazostahili kurekodiwa, kisha unatoa amri zinazozizalisha na hesabu zinazozigeuza kuwa uamuzi.
Kwa nini takwimu za tokens kwa sekunde zilizochapishwa si namba yako
DigitalOcean ilichapisha takwimu za throughput mnamo Julai 2026 kwa NVIDIA H200 moja inayotumia llama3.3-70b-instruct katika FP8 (8-bit floating point) chini ya vLLM. Takwimu hizi ni muhimu lakini si zako.
Data iliyo nyuma ya chati hii
[
{
"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"
}
]Kila mstari hapo juu umenukuliwa kutoka kwenye ukurasa huo, na miwili kati yake ni kiwango cha chini cha masafa yanayotolewa, kwa hivyo soma hayo mawili kama msingi. Hakuna chochote katika chati hii kilichopimwa na sisi.
Anza na mistari miwili ya mwisho. Kichwa cha habari ni 4,071.6 tok/s, wakati kiwango cha output pekee ni 2,036 tok/s. Kichwa cha habari huhesabu tokens za input na output pamoja. Jaribio hilo lilitumia tokens 1,024 za input dhidi ya tokens 1,024 za output, kwa hivyo karibu nusu ya kichwa cha habari ni output. Mgawanyo huu ni muhimu kwa sababu output ndiyo nusu ya polepole. Prefill (kusoma prompt) huchakata tokens zote za input kwa hatua moja. Decode (kuandika jibu) huzalisha token moja kwa wakati mmoja. Kichwa cha habari cha total-throughput hupata wastani wa namba ya bei nafuu na namba ya gharama kubwa.
Sasa mstari wa kwanza. H200 hiyohiyo inayohudumia ombi moja kwa wakati mmoja huzalisha 47 tok/s, kwa hivyo takwimu ya saturation ni zaidi ya mara arobaini juu kwenye vifaa vinavyofanana. Pengo hilo lipo kwa sababu hatua moja ya decode huiacha GPU ikisubiri kumbukumbu kwa muda mwingi, na maombi ya wakati mmoja hujaza muda huo wa kutofanya kazi. Mstari wa pili, 236 tok/s, ni H100 moja kwenye model hiyohiyo, inayozuiwa na KV cache (cache ya key na value, kumbukumbu ya kila ombi ambayo mazungumzo yanayohudumiwa huweka kwenye kadi). Kadi ya 80 GB hushikilia maombi machache ya wakati mmoja kwa model ya 70B, kwa hivyo saturation yake huwa chini.
Badilisha model au badilisha uwiano wa input kwa output na kila namba hapo juu itabadilika. Takwimu zilizochapishwa huweka matarajio yako, si bajeti yako, ambayo ni kanuni hiyohiyo inayotumika katika kufanya benchmarking ya VPS kwa uaminifu kwenye diski na mtandao.
Nambari nne muhimu
- Time to first token, TTFT. Muda unaopita kati ya kutuma ombi na kupokea token ya kwanza. Hii ni jumla ya muda wa prefill na muda wa kusubiri kwenye foleni. Mtumiaji huhisi muda huu moja kwa moja.
- Output tokens per second, per stream. Kasi ya uandishi wa jibu moja baada ya kuanza. Zaidi ya takriban 20 tok/s, kasi hii inakuwa kubwa kuliko uwezo wa kusoma wa watu wengi, hivyo kasi ya ziada hapa haina faida kubwa.
- Saturated total output throughput. Jumla ya token zote zinazozalishwa kwa wakati mmoja wakati seva imelemewa na kazi. Hii ndiyo nambari inayopima uwezo wa mfumo, na ndiyo inayohalalisha gharama za GPU.
- p50 na p99 TTFT chini ya concurrency. p50 ni ombi la katikati. p99 ni thamani ambayo maombi 99 kati ya 100 hayazidi. Msongamano kwenye foleni huonekana kwanza kwenye p99.
Nambari mbili za kwanza huboreka wakati seva haina kazi nyingi. Nambari ya tatu huboreka wakati seva ina shughuli nyingi. Nambari hizi hupingana, ndiyo maana hakuna nambari moja inayoweza kuelezea utendaji wa seva ya kuhudumia maombi.
Rekebisha urefu wa ingizo na towe kabla ya kupima
Througput inategemea umbo la trafiki. Prompt ya token 4,000 yenye jibu la token 50 ni kazi inayotegemea sana prefill. Prompt ya token 200 yenye jibu la token 2,000 ni kazi inayotegemea sana decode. Seva hiyo hiyo hutoa idadi tofauti sana ya token kwa sekunde kwa kazi hizo mbili, kwa hivyo chagua uwiano mmoja, uandike kando ya kila namba unayorekodi, na usiwahi kulinganisha uwiano tofauti. Ingizo la 1,024 na towe la 1,024 ni chaguo-msingi la kuridhisha kwa sababu wachuuzi kadhaa huchapisha matokeo kwa uwiano huo. Ikiwa unajua trafiki yako halisi, tumia trafiki yako halisi.
Lazimisha pia urefu wa towe. Model inayofikia stop token baada ya token 60 hutoa muda mfupi wa utendaji ambao hauwezi kulinganishwa na ule kamili: TTFT inakuwa sehemu kubwa zaidi ya muda huo, jambo ambalo hushusha throughput ya towe kadiri benchmark inavyoihesabu, ingawa kila ombi hukamilika mapema zaidi. Flag ya --ignore-eos katika mteja wa benchmark wa vLLM hufanya kila ombi kuzalisha idadi kamili ya token zilizoelekezwa, hivyo mbio mbili hubaki kulinganishika. Chaguo la model hubadilisha namba hizi zaidi ya flag yoyote: kutosheleza model ya Qwen 3 kwenye GPU moja ya VPS inashughulikia upande wa kumbukumbu wa chaguo hilo.
Pima mtiririko mmoja kwanza
Anza na hali rahisi zaidi. Hii ni hatua ya kuhakiki mfumo na kuweka kiwango cha juu cha utendaji. Ollama huchapisha muda wake wa uchakataji.
ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."Mstari wa kusoma ni eval rate, ambao ni idadi ya token zinazozalishwa kwa sekunde. prompt eval rate ni kasi ya prefill, na load duration ni muda uliotumika kupakia model kwenye VRAM. Katika ombi la kwanza baada ya kuanzisha seva (cold start), load duration huwa kubwa, kwa hivyo total duration inaweza kupotosha. Tekeleza amri hiyo mara mbili na usome matokeo ya pili. Ollama huondoa model isiyotumika kwenye kumbukumbu baada ya dakika tano kwa chaguo-msingi, kwa hivyo kusubiri muda mrefu kati ya majaribio kutakurudisha kwenye hali ya kuanza upya.
Sehemu hizo hizo zinapatikana kupitia API, ambayo ni rahisi zaidi kuandikia script.
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 ni nanoseconds, kwa hivyo kugawanya kwa 1,000,000,000 kunatoa sekunde. Mgawanyo huo ndio hasa unaoelekezwa na nyaraka za API ya Ollama kwa ajili ya token kwa sekunde. Ikiwa seva bado haijawashwa, kujihudumia LLM kwa kutumia Ollama kwenye VPS inaelezea usakinishaji na kitengo cha systemd.
TTFT inahitaji ombi la mtiririko (streaming request), na curl inaweza kukupimia muda huo.
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 ni wakati ambapo byte ya kwanza ya mwili wa jibu inafika. Katika kukamilisha mazungumzo ya mtiririko, byte hiyo ni ya tukio la kwanza lililotumwa na seva, ambalo linaweza kuwa token ya kwanza ya maudhui au delta ya jukumu pekee iliyotumwa kabla yake. Kwa hivyo, chukulia thamani hiyo kama TTFT kwa makadirio ya tukio moja. Inatosha kulinganisha majaribio mawili kwenye seva moja.
Namba za mtiririko mmoja huonyesha uwezo wa seva kwa namna nzuri kupita kiasi. TTFT ndiyo bora zaidi itakavyokuwa, kwa sababu hakuna kitu kilichopangwa kwenye foleni mbele yako. Kasi ya kila mtiririko ndiyo bora zaidi itakavyokuwa, kwa sababu kadi nzima inahudumia ombi moja. Hakuna kati ya hizi inayoeleza uwezo halisi wa seva hiyo.
Jinsi ya kufanya concurrency sweep
Sweep huendesha mzigo mmoja wa kazi uliopangwa kwa kuongeza concurrency hatua kwa hatua na kurekodi matokeo ya kila hatua. vLLM husafirisha mteja (client) kwa ajili ya kazi hii, na hutumia OpenAI API, kwa hivyo inafanya kazi pia na Ollama na huduma nyingine zozote zinazoendana na OpenAI.
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 huweka kikomo cha maombi yanayochakatwa kwa wakati mmoja, na ndiyo variable unayofanya sweep. --num-prompts ni jumla ya maombi yaliyotumwa, kwa hivyo iweke karibu mara kumi ya concurrency ili kupata wastani thabiti. Muhtasari huchapisha Output token throughput (tok/s): na Total token throughput (tok/s):, kisha Mean TTFT (ms):, Median TTFT (ms): na P99 TTFT (ms): chini ya kichwa cha habari cha Time to First Token.
Hakuna kiwango cha rate kwa kila stream katika matokeo hayo, lakini kinaweza kupatikana kwa mgawanyo mmoja. Mean TPOT (ms): ni muda wa wastani kwa kila token ya pato baada ya ile ya kwanza, kwa hivyo 25 ms kwa kila token ni sawa na 40 tokens kwa sekunde kwa kila stream. Kugawanya throughput ya pato kwa concurrency kunatoa jibu lilelile.
Kisha iweke kwenye loop, huku ukihifadhi kila 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"
doneKusoma faili za JSON zilizohifadhiwa
Kila run huandika faili moja, kwa hivyo toa sehemu unazozihitaji kutoka kwenye faili zote kwa wakati mmoja.
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 ni tokens za pato kwa sekunde. total_token_throughput huongeza tokens za ingizo, kwa hivyo kwa uwiano wa 1:1 inakaribia mara mbili. p99_ttft_ms ingekuwepo hata bila --metric-percentiles, kwa sababu flag hiyo ina default ya 99. Namba 50 katika amri hiyo ndiyo inayoongeza p50_ttft_ms kando ya median_ttft_ms ambayo kila metric iliyotajwa katika --percentile-metrics huipata. Omba percentile ambayo hukuomba, kama vile .p90_ttft_ms, na jq itachapisha null.
Uchanganuzi wa concurrency sweep unaonyesha nini hasa?
Data iliyo nyuma ya chati hii
[
{
"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
}
]Safu hizo 6 ni kielelezo cha umbo linalotokana na sweep kwenye seva ndogo ya GPU inayoweza kukodishwa, kwa viwango vinavyokubalika. Hizi si vipimo vya seva yako, na si takwimu za muuzaji. Endesha loop iliyo hapo juu na uzibadilishe na zako.
Soma umbo hilo, kwa sababu umbo ndilo linaloweza kutumika kwa ujumla. Katika stream moja, seva nzima inazalisha 92 tokens kwa sekunde ikiwa na p99 TTFT ya 61 ms. Katika 128 streams, jumla inafikia 2304 tokens kwa sekunde, mara ishirini na tano zaidi, wakati kila stream binafsi inashuka hadi 18 tokens kwa sekunde na p99 TTFT inafikia 3820 ms. Jumla ya throughput inapanda kwa sababu batching inageuza muda wa kusubiri wa kumbukumbu kuwa kazi yenye tija. Kasi ya kila stream inashuka kwa sababu nguvu ileile ya kompyuta sasa inagawanywa.
Marudio ya mwisho ndiyo yanayotoa ishara. Kuongeza kutoka 64 hadi 128 streams kunaongeza chini ya asilimia sita kwenye jumla, huku p99 TTFT ikiongezeka mara tatu, jambo linalomaanisha maombi yanapanga foleni badala ya kuendeshwa, aidha kwa sababu KV cache imejaa au kwa sababu seva imefikia kikomo cha scheduling kama vile max_num_seqs ya vLLM. Sehemu sahihi ya uendeshaji iko mapema zaidi: katika 32 streams, seva bado inatoa 1728 tokens kwa sekunde, asilimia 75 ya uwezo wake wa juu, kwa 54 tokens kwa sekunde kwa kila stream na p99 TTFT ya 498 ms. Ripoti sehemu hiyo kama uwezo wako. Kilele cha curve ni namba ambayo huwezi kuitumia kuhudumia watumiaji.
Ollama na vLLM hazipimi kitu kimoja
Endesha jaribio hilo dhidi ya seva ya kawaida ya Ollama na jumla haitabadilika sana. OLLAMA_NUM_PARALLEL imewekwa kuwa 1 kwa chaguo-msingi, kwa hivyo ombi moja huendeshwa wakati mengine yakisubiri, na foleni ndiyo inayofanya p99 TTFT kupanda huku jumla ya pato likibaki vilevile. Iongeze kabla ya kupima chochote.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=8"Anzisha upya ukitumia sudo systemctl restart ollama, kisha thibitisha kuwa modeli bado inatoshea. Kila nafasi ya sambamba (parallel slot) hupata sehemu yake ya context window, kwa hivyo nyaraka za Ollama zinaeleza kuwa context ya 2K yenye maombi 4 ya sambamba hutenga 8K. Ikiwa utaongeza idadi ya nafasi hizo kwa kiasi kikubwa, modeli itatoka nje ya VRAM. Angalia ollama ps: safu ya PROCESSOR inayosomeka kama 48%/52% CPU/GPU inamaanisha kuwa sehemu ya modeli iko kwenye CPU, na throughput sasa itashuka unapoongeza concurrency badala ya kupanda. Baada ya nafasi za sambamba, maombi hupangwa kwenye foleni hadi OLLAMA_MAX_QUEUE, 512 kwa chaguo-msingi, ambapo baada ya hapo seva hujibu 503.
vLLM hutumia continuous batching, kwa hivyo inaruhusu maombi mapya kuingia kwenye batch inayoendelea kadiri nafasi zinavyopatikana, na mkondo wake huendelea kupanda hadi kitu fulani kiishe: kwa kawaida KV cache, ingawa kikomo kilichowekwa kama max_num_seqs au mzigo wa CPU scheduling unaweza kuifanya iwe tambarare mapema zaidi. Ollama inaboresha kwa ajili ya modeli moja, mashine moja, na gharama ndogo ya usanidi. Kwa hivyo, injini hizi mbili hutoa majibu tofauti kwa jaribio lilelile, ambalo ndilo mada kuu ya Ollama na vLLM zikilinganishwa kama injini za kuhudumia. Rekodi ni injini ipi na toleo lipi lililozalisha kila namba.
Njia tano za kupima kitu kisicho sahihi
- Mteja yuko mbali. Kufanya benchmarking kutoka kwenye laptop yako kupitia Internet huongeza muda wa round trip kwenye kila TTFT, kwa hivyo unapima muunganisho wako wa nyumbani. Endesha mteja katika eneo (region) moja na seva.
- Model ilikuwa baridi (cold). Ombi la kwanza hubeba mzigo wa kupakia uzito (weight loading), na kwenye vLLM linaweza pia kubeba gharama ya graph capture. Tuma batch ya warmup na utupe matokeo yake.
- Prefix caching imekujibu. vLLM huwezesha prefix caching ya kiotomatiki kwa chaguo-msingi, kwa hivyo kutuma prompt ileile mara kwa mara hupima cache badala ya prefill, na TTFT hushuka hadi sehemu ndogo ya thamani halisi.
--dataset-name randomhuepuka hili kwa sababu kila prompt ni tofauti. Ili kuwa na uhakika, anzisha seva kwa kutumia--no-enable-prefix-caching. - Matokeo yalikuwa mafupi. Kwa majibu ya token 32, TTFT hutawala kila ombi na tokens per second yako inafafanua prefill pekee. Tumia
--ignore-eosyenye urefu wa matokeo wa kweli. - Umeripoti concurrency 1 pekee. Hii hutoa TTFT inayopendeza zaidi kwenye karatasi, na ni ingizo sahihi la gharama ikiwa maombi yako halisi hayapishani kamwe. Ikiwa yanapishana, gharama hutegemea throughput unayodumisha kwenye concurrency inayozalishwa na trafiki yako halisi, kwa hivyo pima hapo pia.
Badilisha namba uliyopima kuwa uamuzi
Chukua throughput ya pato (output) inayoonyeshwa na sweep yako katika concurrency inayofikiwa na trafiki yako halisi, kisha uilinganishe na bei ya per-token. Hiyo ni takwimu ya saturation ikiwa tu maombi ya kutosha yanapishana ili kuweka batch ikiwa imejaa; workload inayotuma ombi moja kwa wakati mmoja lazima itumie kiwango chake cha single-stream. Break-even ni mgawanyo mmoja, pindi unapopanga bei ya input tokens zinazoambatana na kila output token:
cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600Fanya hesabu kwa kutumia bei za DigitalOcean za Julai 2026. Endpoint yao ya inference iliyojitolea ya H200 ilikuwa $4.47 kwa saa, na Llama 3.3 70B ya serverless ilikuwa $0.65 kwa kila milioni ya tokens kwa input na $0.65 kwa kila milioni kwa output. Kwa uwiano wa 1:1 uliotumika hapo juu, kila milioni ya output tokens huambatana na milioni moja ya input tokens, kwa hivyo bei halisi ni $1.30 kwa kila milioni ya output tokens. Kwa hivyo 4.47 ikigawanywa kwa 1.30 ni takriban milioni 3.44 ya output tokens kwa saa, na kugawanya kwa sekunde 3,600 kunatoa takriban 955 output tokens kwa sekunde, au takriban 1,910 tokens kwa sekunde ukijumlisha input na output. Bei ni zao. Mgawanyo ni wetu. Tulipokagua tarehe 25 Oktoba 2026, endpoint ya H200 ilikuwa bado $4.47 kwa saa, lakini DigitalOcean ilisitisha Llama 3.3 70B ya serverless tarehe 18 Agosti 2026 na kuelekeza watumiaji kwenye Llama 4 Maverick, iliyoorodheshwa kwa $0.25 kwa kila milioni ya input tokens na $0.87 kwa kila milioni ya output tokens. Huo ni mfano tofauti, kwa hivyo unahitaji sweep yake yenyewe kabla ya kulinganisha huko kuwa na maana yoyote.
Neno linaloamua hili ni sustained (endelevu). Kufikia 955 output tokens kwa sekunde katika saturation kwa saa mbili kwa siku si 955 output tokens kwa sekunde endelevu, kwa sababu unalipia saa nyingine ishirini na mbili pia. Kukodisha kadi kama GPU Droplet hakupunguzi kizingiti: tarehe 25 Oktoba 2026 bei ya Droplet ya DigitalOcean iliorodhesha H200 kwa $4.47 kwa saa on demand, sawa na endpoint, na NVIDIA Droplets zao za bei nafuu zaidi, RTX 4000 kwa $0.76 kwa saa na L40S au RTX 6000 kwa $1.57 kwa saa, ni ndogo mno kuhifadhi mfano wa 70B katika FP8. Kwa hivyo kulingana na takwimu hapo juu, H200 inayofikia saturation ya 2,036 output tokens kwa sekunde lazima iwe na wastani wa takriban asilimia 47 ya kilele hicho katika kila saa unayolipia ili tu kulingana na $0.65 kwa kila milioni ya tokens za input na output, na chini ya hapo bei ya per-token inashinda. Saa za GPU zisizofanya kazi (idle), si tokens za polepole, ndizo zinazozamisha self-hosting mara nyingi.
Kwa hivyo uamuzi wako una inputs mbili. Sweep inakupa ukomo (ceiling). Mfumo wa trafiki yako unakupa sehemu ya ukomo huo unayokusanya kihalisi. Zidisha hizo, kisha chukua matokeo hayo hadi GPU VPS dhidi ya break-even ya API ya per-token na usome jibu kwa ajili ya ujazo wako.
FAQ
Ni kiwango gani kizuri cha tokens kwa sekunde kwa LLM inayojiendesha yenyewe?
Kuna majibu mawili, kwa sababu kipimo hiki kinafanya kazi mbili. Kwa mtu mmoja anayesoma matokeo, chochote kinachozidi takriban 20 output tokens kwa sekunde kwa kila mkondo (stream) ni kasi zaidi kuliko kasi ya kusoma, hivyo kasi zaidi haisaidii. Kwa gharama, namba inayojali ni jumla ya throughput ya matokeo unayoweza kudumisha chini ya mzigo wako halisi, na "nzuri" inamaanisha chochote kinachokufikisha kwenye kiwango cha faida. Kwa gharama ya $0.65 kwa kila milioni ya tokens, iwe ni input au output, kwenye seva inayogharimu $4.47 kwa saa, kiwango hicho cha chini kipo karibu na 955 output tokens kwa sekunde zilizodumishwa kwa uwiano wa 1:1 na bei za Julai 2026. Mkondo mmoja kwenye model kubwa haufikii kiwango hicho, ndiyo sababu batching ipo.
Kwa nini throughput ya Ollama inabaki palepale ninapoongeza maombi ya wakati mmoja?
OLLAMA_NUM_PARALLEL ina default ya 1, kwa hivyo seva huendesha ombi moja kwa wakati mmoja kwa kila model na kupanga mengine kwenye foleni, hadi OLLAMA_MAX_QUEUE (512 kwa default) kabla ya kurudisha 503. Jumla ya matokeo inabaki palepale wakati p99 TTFT inapanda, ambayo ni ishara ya foleni badala ya GPU yenye shughuli nyingi. Weka variable hiyo kwenye systemd drop-in na uanzishe upya, kisha angalia ollama ps, kwa sababu kila slot ya parallel huzidisha context iliyotengwa na inaweza kusukuma sehemu ya model kwenye CPU.
Je, nipime muda wa token ya kwanza (TTFT) au tokens kwa sekunde?
Pima yote mawili, kwa sababu huenda katika mwelekeo tofauti mzigo unapoongezeka. TTFT ndiyo kitu ambacho mtumiaji anahisi, na throughput iliyojaa ya matokeo ndiyo inayojitokeza kwenye ankara yako. Rekodi p50 na p99 TTFT katika kila hatua ya concurrency, kisha chagua concurrency ya juu zaidi ambapo p99 TTFT bado inakubalika kwako. Ripoti throughput katika hatua hiyo kama uwezo wako, siyo kiwango cha juu kabisa kutoka kwenye kilele cha grafu.
Je, namba ya juu ya tokens kwa sekunde inamaanisha gharama ya chini kwa kila token kila wakati?
Hapana. Gharama kwa kila token ni bei ya saa iliyogawanywa na tokens ambazo seva imezalisha kwa saa hiyo, kwa hivyo seva ya haraka inayokaa bila kazi siku nzima bado ina gharama kubwa kwa kila token. Matumizi (utilisation) ndiyo huamua, siyo kasi ya kilele. Angalia vitengo pia: jumla ya token throughput inayotajwa huhesabu input tokens, kwa hivyo kwa uwiano wa 1:1 wa input kwa output, ni karibu mara mbili ya kiwango cha output. Ikiwa API unayolinganisha nayo inatoza input tokens pamoja na output, piga bei ya pande zote mbili kabla ya kulinganisha.