SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-26

Paano sukatin ang tokens per second ng local LLM

Alamin ang totoong throughput ng local LLM gamit ang concurrency sweep. Ikumpara ang tokens per second sa per-token billing bago mag-rent ng GPU.

Bakit ang tokens per second ang nagtatakda kung sulit ang GPU

Ang tokens per second ay ang rate kung gaano kabilis gumagawa ng output text ang server mo. Ito ang numerong nagtatakda kung mas mura ang pag-rent ng GPU kaysa sa pagbabayad sa API batay sa bawat token. Sinisingil ang GPU box kada oras kahit ginagamit o idle ito. Ang hosted API naman ay sinisingil batay sa token. Kaya lamang mas sulit ang GPU kung sapat na mataas ang output rate sa karamihan ng mga oras na binabayaran mo.

Ibig sabihin, kailangan mo ng aktuwal na measurement, hindi ng numerong nabasa mo lang kung saan. Tinutukoy sa page na ito ang apat na numerong dapat itala. Ibinibigay rin dito ang mga command na gumagawa ng mga ito at ang arithmetic na ginagamit para makagawa ng desisyon.

Bakit hindi mo makukuha ang inilathalang bilang ng tokens per second

Nag-publish ang DigitalOcean noong July 2026 ng mga throughput figure para sa isang NVIDIA H200 na nagpapatakbo ng llama3.3-70b-instruct sa FP8 (8-bit floating point) gamit ang vLLM. Kapaki-pakinabang ang mga figure na ito, pero hindi ibig sabihin na iyon na ang makukuha mo.

TsartPublished DigitalOcean H200 figures, llama3.3-70b-instruct FP8, July 2026
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Ang bawat row sa itaas ay kinuha mula sa page na iyon. Dalawa sa mga ito ang mababang dulo ng isang range na ibinigay nito, kaya ituring ang dalawang iyon bilang minimum. Walang numerong nasa chart na ito ang sinukat namin.

Unahin ang huling dalawang row. Ang headline ay 4,071.6 tok/s, samantalang ang output-only rate ay 2,036 tok/s. Kasama sa headline ang input at output tokens. Gumamit ang test na iyon ng 1,024 input tokens at 1,024 output tokens, kaya halos kalahati ng headline ang output. Mahalaga ang paghahating ito dahil ang output ang mabagal na bahagi. Pinoproseso ng prefill (pagbasa sa prompt) ang lahat ng input tokens sa isang pass. Ang decode (pagsulat ng sagot) ay gumagawa ng isang token kada pagkakataon. Ang headline na total-throughput ay nag-a-average ng murang bahagi at mamahaling bahagi.

Ngayon, tingnan ang unang row. Ang parehong H200, kapag isang request lang ang pinoproseso bawat pagkakataon, ay nakakagawa ng 47 tok/s. Ibig sabihin, mahigit apatnapung beses na mas mataas ang saturated figure sa parehong hardware. Nangyayari ang agwat na ito dahil sa karamihan ng oras ay naghihintay ang GPU sa memory sa bawat decode step. Pinupunan ng sabay-sabay na requests ang idle time na iyon. Ang ikalawang row, 236 tok/s, ay mula sa isang H100 na nagpapatakbo ng parehong model. Nililimitahan ito ng KV cache (ang key at value cache, o per-request memory na pinananatili ng isang served conversation sa card). Mas kaunting concurrent requests para sa isang 70B model ang kasya sa 80 GB card, kaya mas mababa ang saturation nito.

Kapag binago mo ang model o ang ratio ng input sa output, magbabago rin ang bawat numerong nasa itaas. Ang mga published figure ay gabay sa iyong inaasahan, hindi batayan ng iyong budget. Ito rin ang prinsipyong ginagamit sa tapat na pag-benchmark ng VPS pagdating sa disk at network.

Ang apat na numerong mahalaga

  • Time to first token, TTFT. Ang delay mula sa pagpapadala ng request hanggang sa pagdating ng unang output token. Binubuo ito ng prefill time at queue time. Direktang nararamdaman ito ng user.
  • Output tokens per second, bawat stream. Kung gaano kabilis nabubuo ang isang sagot matapos itong magsimula. Kapag lampas sa humigit-kumulang 20 tok/s, mas mabilis na ito kaysa sa bilis ng pagbasa ng karamihan, kaya kaunti na lamang ang pakinabang ng dagdag na bilis.
  • Saturated total output throughput. Ang kabuuan ng output mula sa lahat ng kasabay na stream kapag fully loaded ang server. Ito ang sukatan ng capacity, at ito ang direktang may epekto sa GPU bill.
  • p50 at p99 TTFT under concurrency. Ang p50 ang request na nasa gitna ng distribution. Ang p99 ang halagang mas mababa rito ang 99 sa bawat 100 request. Laging unang lumilitaw sa p99 ang epekto ng queueing.

Gumaganda ang unang dalawa kapag kaunti ang load ng server. Gumaganda naman ang pangatlo kapag mataas ang load nito. Magkakasalungat ang mga ito, kaya walang iisang numero na sapat upang ilarawan ang isang serving server.

Ayusin ang input at output length bago magsukat

Nakadepende ang throughput sa hugis ng traffic. Ang prompt na may 4,000 token at sagot na may 50 token ay prefill-heavy na workload. Ang prompt na may 200 token at sagot na may 2,000 token ay decode-heavy na workload. Magkaibang-magkaiba ang tokens per second na iuulat ng parehong server para sa dalawang ito. Kaya pumili ng isang ratio, isulat ito sa tabi ng bawat itatala mong numero, at huwag maghambing ng mga resultang magkaiba ang ratio. Makatuwirang default ang 1,024 input at 1,024 output dahil may ilang vendor na naglalathala ng resulta gamit ang ratio na ito. Kung alam mo ang aktuwal mong traffic, gamitin ang aktuwal mong traffic.

Ipatupad din ang output length. Kapag umabot ang isang model sa stop token nito matapos ang 60 token, mas maikli ang run nito at hindi ito maihahambing sa isang buong run. Mas malaking bahagi nito ang TTFT, kaya bumababa ang output throughput ayon sa bilang ng benchmark, kahit mas mabilis matapos ang bawat request. Tinitiyak ng --ignore-eos flag sa vLLM benchmark client na eksaktong itinakdang bilang ang bina-generate ng bawat request. Dahil dito, nananatiling maihahambing ang dalawang run. Mas malaki ang epekto ng pagpili ng model sa mga numerong ito kaysa sa anumang flag: saklaw ng pagkakasyang ng Qwen 3 model sa iisang VPS GPU ang bahagi tungkol sa memory ng pagpiling iyon.

Sukatin muna ang isang stream

Magsimula sa pinakasimpleng kaso. Sanity check ito, at ito rin ang ceiling. Awtomatikong ipinapakita ng Ollama ang sarili nitong timings.

ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."

Ang linyang dapat basahin ay eval rate, na tumutukoy sa output tokens per second. Ang prompt eval rate ay ang prefill rate, at ang load duration ay ang oras na ginugol sa pag-load ng model sa VRAM. Sa unang call pagkatapos ng cold start, malaki ang load duration, kaya nakalilinlang ang total duration. Patakbuhin ang command nang dalawang beses at basahin ang ikalawang resulta. Bilang default, inaalis ng Ollama sa memory ang idle model pagkalipas ng limang minuto, kaya kapag mahaba ang pagitan ng mga run, babalik ka sa cold case.

Pareho ang mga field na ito mula sa API, at mas madali itong i-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))}'

Nasa nanoseconds ang eval_duration, kaya ang paghahati nito sa 1,000,000,000 ay nagbibigay ng mga segundo. Iyan mismo ang division na inirerekomenda sa sariling API documentation ng Ollama para sa tokens per second. Kung hindi pa tumatakbo ang server, inilalarawan sa self-hosting ng LLM gamit ang Ollama sa isang VPS ang pag-install at ang systemd unit.

Kailangan ng TTFT ng streaming request, at maaaring sukatin iyon ng 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}'

Ang time_starttransfer ay ang sandaling dumarating ang unang byte ng response body. Sa isang streaming chat completion, kabilang ang byte na iyon sa unang server-sent event, na maaaring unang content token o role-only delta na ipinapadala bago nito. Kaya ituring ang value bilang TTFT na maaaring mag-iba nang kaunti dahil sa isang event. Sapat ang accuracy nito para ikumpara ang dalawang run sa iisang server.

Dalawang beses na nagpapaganda sa aktuwal na kakayahan ng machine ang single-stream numbers. Pinakamaganda ang TTFT na makukuha mo dahil walang request na nakapila bago sa iyo. Pinakamaganda rin ang per-stream rate na makukuha mo dahil isang request lang ang pinagsisilbihan ng buong card. Hindi ipinapakita ng alinman sa mga ito kung gaano karaming load ang kayang dalhin ng machine.

Paano magpatakbo ng concurrency sweep?

Ang sweep ay nagpapatakbo ng isang nakapirming workload sa pataas na concurrency at itinatala kung ano ang nangyayari sa bawat hakbang. Kasama sa vLLM ang client para dito, at gumagamit ito ng OpenAI API, kaya gumagana rin ito sa Ollama at sa iba pang OpenAI-compatible na serbisyo.

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

Nililimitahan ng --max-concurrency ang mga request na kasalukuyang tumatakbo, at ito ang variable na sine-sweep mo. Ang --num-prompts ang kabuuang bilang ng ipinadalang request, kaya panatilihin itong malapit sa sampung beses ng concurrency para makakuha ng stable na average. Ipinapakita ng summary ang Output token throughput (tok/s): at Total token throughput (tok/s):, saka ang Mean TTFT (ms):, Median TTFT (ms):, at P99 TTFT (ms): sa ilalim ng heading na Time to First Token.

Walang rate bawat stream sa output na iyon, pero isang division lang ang kailangan para makuha ito. Ang Mean TPOT (ms): ay ang average na oras bawat output token pagkatapos ng unang token, kaya ang 25 ms bawat token ay katumbas ng 40 tokens bawat segundo bawat stream. Ang paghahati sa output throughput ayon sa concurrency ay magbibigay ng parehong sagot.

Pagkatapos, i-loop ito at i-save ang bawat 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
Pagbasa sa mga na-save na JSON file

Isang file ang isinusulat ng bawat run, kaya kunin nang sabay-sabay ang mga field na kailangan mo mula sa lahat ng file.

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"
done

Ang output_throughput ay output tokens bawat segundo. Idinaragdag ng total_token_throughput ang input tokens, kaya sa 1:1 ratio ay halos doble ang halaga nito. Lalabas ang p99_ttft_ms kahit wala ang --metric-percentiles, dahil ang default ng flag na iyon ay 99. Ang 50 sa command ang nagdaragdag ng p50_ttft_ms sa tabi ng median_ttft_ms na natatanggap ng bawat metric na nakalista sa --percentile-metrics. Kapag humingi ka ng percentile na hindi mo nirequest, gaya ng .p90_ttft_ms, ipi-print ng jq ang null.

Ano talaga ang ipinapakita ng concurrency sweep?

TsartIllustrative sweep shape: 8B model, one 24 GB GPU, 1024 in / 1024 out
Ang datos sa likod ng tsart na ito
[
  {
    "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
  }
]

Ang 6 row na iyon ay halimbawa ng hugis na nalilikha ng isang sweep sa isang maliit na rented GPU box, batay sa makatwirang order of magnitude. Hindi iyon sukat ng server mo at hindi rin iyon vendor figure. Patakbuhin ang loop sa itaas at palitan ang mga iyon ng sarili mong resulta.

Basahin ang hugis, dahil ang hugis ang maaaring i-generalize. Sa isang stream, ang buong box ay nakakagawa ng 92 tokens bawat segundo, na may p99 TTFT na 61 ms. Sa 128 streams, umaabot ang total sa 2304 tokens bawat segundo, dalawampu't limang beses na mas mataas, habang bumababa ang bilis ng bawat indibidwal na stream sa 18 tokens bawat segundo at umaabot ang p99 TTFT sa 3820 ms. Tumataas ang kabuuang throughput dahil ginagawa ng batching na kapaki-pakinabang na trabaho ang dating idle na paghihintay sa memory. Bumaba ang bilis ng bawat stream dahil pinaghahatian na ng mga ito ang parehong compute.

Ang huling pagdodoble ang mahalagang senyales. Mula 64 hanggang 128 stream, wala pang anim na porsiyento ang nadadagdag sa total, habang humigit-kumulang tatlong beses naman ang itinaas ng p99 TTFT. Ibig sabihin, naka-queue ang mga request sa halip na tumakbo, maaaring dahil puno na ang KV cache o dahil umabot na ang server sa scheduling cap gaya ng max_num_seqs ng vLLM. Mas maaga ang kapaki-pakinabang na operating point: sa 32 stream, nakakabalik pa rin ang box ng 1728 tokens bawat segundo, o 75 porsiyento ng peak nito, sa bilis na 54 tokens bawat segundo bawat stream at p99 TTFT na 498 ms. I-report ang puntong iyon bilang capacity mo. Ang peak ng curve ay hindi bilang na maaari mong gamitin sa pag-serve sa mga user.

Hindi pareho ang sinusukat ng Ollama at vLLM

Patakbuhin ang sweep na iyon laban sa default na Ollama server at halos hindi magbabago ang total. Naka-default sa 1 ang OLLAMA_NUM_PARALLEL, kaya isang request lang ang tumatakbo habang naghihintay ang iba. Dahil sa queue, tumataas ang p99 TTFT habang nananatiling halos pareho ang total output. Itaas muna ito bago magsukat.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=8"

Mag-restart gamit ang sudo systemctl restart ollama, pagkatapos ay tiyaking kasya pa rin ang model. May sariling bahagi ng context window ang bawat parallel slot. Kaya ayon sa dokumentasyon ng Ollama, ang 2K context na may 4 parallel request ay naglalaan ng 8K. Kapag itinaas nang sobra ang bilang ng slot, lumalampas ang model sa VRAM. Suriin ang ollama ps: kung ang PROCESSOR column ay may value na tulad ng 48%/52% CPU/GPU, nasa CPU ang bahagi ng model. Dahil dito, bababa ang throughput habang dinaragdagan ang concurrency sa halip na tumaas. Pag nalampasan na ang parallel slots, nag-queue ang mga request hanggang sa OLLAMA_MAX_QUEUE, na naka-default sa 512. Pagkatapos nito, sasagot ang server ng 503.

Gumagamit ang vLLM ng continuous batching. Tumatanggap ito ng mga bagong request sa kasalukuyang batch kapag may nabakanteng slot. Patuloy na tumataas ang curve hanggang maubusan ng resource ang system. Karaniwang KV cache ang nauubos, ngunit maaari rin itong maagang ma-flat dahil sa configured cap gaya ng max_num_seqs o sa overhead ng CPU scheduling. Ino-optimize ng Ollama ang paggamit para sa isang model, isang machine, at mababang setup cost. Dahil dito, magkaiba ang sagot ng dalawang engine sa parehong sweep. Ito ang tunay na paksa ng Paghahambing sa Ollama at vLLM bilang serving engine. Itala kung aling engine at aling version ang gumawa ng bawat value.

Limang paraan para masukat ang maling bagay

  • Malayo ang client. Kapag nag-benchmark mula sa laptop gamit ang internet, idinaragdag ng round trip mo ang sarili nitong oras sa bawat TTFT, kaya ang nasusukat mo ay ang home connection mo. Patakbuhin ang client sa parehong region ng server.
  • Cold pa ang model. Binabayaran ng unang request ang pag-load ng weights, at sa vLLM maaari ring kasama rito ang graph capture. Magpadala ng warmup batch at itapon ang resulta.
  • Sinagot ka ng prefix caching. Naka-enable bilang default sa vLLM ang automatic prefix caching, kaya kapag paulit-ulit mong ipinapadala ang parehong prompt, cache ang nasusukat sa halip na prefill, at bumababa ang TTFT sa maliit na bahagi ng tunay na halaga. Iniiwasan ito ng --dataset-name random dahil magkakaiba ang bawat prompt. Para makatiyak, simulan ang server gamit ang --no-enable-prefix-caching.
  • Maikli ang mga output. Sa 32-token na mga sagot, nangingibabaw ang TTFT sa bawat request, kaya ang tokens per second mo ay talagang naglalarawan ng prefill. Gamitin ang --ignore-eos na may makatotohanang output length.
  • Concurrency 1 lang ang iniulat mo. Ito ang nagbibigay ng pinakamababang TTFT sa sheet, at tamang input lamang ito para sa cost kung hindi kailanman nagsasapawan ang mga totoong request mo. Kung nagsasapawan ang mga ito, nakadepende ang cost sa throughput na napapanatili mo sa concurrency na aktuwal na nalilikha ng traffic mo, kaya sukatin din sa antas na iyon.

Gawing desisyon ang nasukat mong numero

Kunin ang output throughput na ipinakita ng iyong sweep sa concurrency na naaabot ng aktuwal mong traffic, at ikumpara ito sa per-token pricing. Saturated figure lamang ito kung sapat ang nag-o-overlap na requests para mapanatiling puno ang batch; ang workload na tig-iisang request lang ang ipinapadala ay dapat gumamit ng single-stream rate nito. Isang division lang ang break-even kapag isinama mo sa presyo ang input tokens na dumarating kasama ng bawat 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 / 3600

Gamitin natin ang mga presyo ng DigitalOcean noong July 2026. Ang dedicated inference endpoint nila para sa H200 ay $4.47 bawat oras, at ang serverless Llama 3.3 70B ay $0.65 bawat milyong tokens para sa input at $0.65 bawat milyon para sa output. Sa 1:1 ratio na ginamit sa itaas, may kasamang isang milyong input tokens ang bawat milyong output tokens, kaya ang effective price ay $1.30 bawat milyong output tokens. Samakatuwid, ang 4.47 na hinati sa 1.30 ay humigit-kumulang 3.44 milyong output tokens bawat oras, at kapag hinati sa 3,600 segundo, humigit-kumulang 955 output tokens bawat segundo, o humigit-kumulang 1,910 tokens bawat segundo kung pagsasamahin ang input at output. Ang mga presyo ay mula sa kanila. Ang division ay atin. Nang mag-check kami noong 25 October 2026, $4.47 bawat oras pa rin ang presyo ng H200 endpoint, ngunit dineprecate ng DigitalOcean ang serverless Llama 3.3 70B noong 18 August 2026 at itinuturo ang users sa Llama 4 Maverick, na nakalista sa $0.25 bawat milyong input tokens at $0.87 bawat milyong output tokens. Ibang model iyon, kaya kailangan nito ng sariling sweep bago maging makabuluhan ang comparison.

Ang salitang nagpapasya rito ay sustained. Ang pag-abot sa 955 output tokens bawat segundo kapag saturated sa loob ng dalawang oras bawat araw ay hindi nangangahulugang 955 output tokens bawat segundo ang sustained rate, dahil binabayaran mo rin ang natitirang dalawampu't dalawang oras. Hindi rin ibinababa ng pagrenta ng card bilang GPU Droplet ang threshold: noong 25 October 2026, nakalista sa Droplet pricing ng DigitalOcean ang H200 sa $4.47 bawat oras on demand, kapareho ng endpoint, at masyadong maliit para maglaman ng 70B model sa FP8 ang pinakamurang NVIDIA Droplets nito—ang RTX 4000 sa $0.76 bawat oras at ang L40S o RTX 6000 sa $1.57 bawat oras. Kaya batay sa mga numerong nasa itaas, ang H200 na umaabot sa saturation na 2,036 output tokens bawat segundo ay kailangang magkaroon ng average na humigit-kumulang 47 porsiyento ng peak na iyon sa bawat oras na binabayaran mo para lamang tumapat sa $0.65 bawat milyong tokens para sa input at output. Kapag mas mababa rito, mas pabor ang per-token price. Karaniwang idle GPU hours, hindi mababagal na tokens, ang nagpapabigat sa self-hosting.

Dalawa ang input ng iyong desisyon. Ibinibigay ng sweep ang ceiling. Ibinibigay ng traffic pattern mo ang aktuwal na porsiyento ng ceiling na nakokolekta mo. I-multiply ang mga ito, pagkatapos ay gamitin ang resulta sa GPU VPS kumpara sa per-token API break-even at tingnan ang sagot para sa volume mo.

FAQ

Ano ang magandang tokens per second para sa isang self-hosted LLM?

May dalawang sagot dahil dalawang gawain ang sinusukat ng metric na ito. Para sa isang taong nagbabasa ng output, sapat na ang humigit-kumulang 20 output tokens per second bawat stream dahil mas mabilis na ito kaysa sa bilis ng pagbabasa. Hindi na makatutulong ang mas mataas pa rito. Para sa cost, ang mahalaga ay ang kabuuang output throughput na kaya mong panatilihin sa aktuwal mong load. Ang magandang halaga ay yaong lumalampas sa break-even point. Kung $0.65 bawat million tokens ang singil para sa input at output, at $4.47 bawat oras ang halaga ng server, nasa humigit-kumulang 955 output tokens per second ang break-even floor sa sustained na 1:1 ratio at mga presyong umiiral noong July 2026. Hindi ito naaabot ng isang stream sa malaking model. Ito ang dahilan kung bakit ginagamit ang batching.

Bakit hindi nagbabago ang Ollama throughput ko kapag nagdagdag ako ng concurrent requests?

Ang default ng OLLAMA_NUM_PARALLEL ay 1, kaya isang request lang bawat model ang pinoproseso ng server at naka-queue ang iba, hanggang OLLAMA_MAX_QUEUE (512 bilang default), bago ito magbalik ng 503. Nananatiling pareho ang kabuuang output habang tumataas ang p99 TTFT. Ipinapakita nito na queue ang bottleneck, hindi abalang GPU. Itakda ang variable sa isang systemd drop-in at mag-restart. Pagkatapos, tingnan ang ollama ps dahil bawat parallel slot ay nagpaparami sa inilaan na context at maaaring magtulak sa bahagi ng model papunta sa CPU.

Dapat ko bang sukatin ang time to first token o tokens per second?

Pareho, dahil magkasalungat ang pagbabago ng mga ito habang tumataas ang load. Ang TTFT ang direktang nararamdaman ng user, samantalang ang saturated output throughput ang makikita sa iyong invoice. Itala ang p50 at p99 TTFT sa bawat concurrency step. Pagkatapos, piliin ang pinakamataas na concurrency kung saan katanggap-tanggap pa sa iyo ang p99 TTFT. Iulat ang throughput sa puntong iyon bilang iyong capacity, hindi ang maximum na halaga sa tuktok ng curve.

Palagi bang nangangahulugan ng mas mababang cost per token ang mas mataas na tokens per second?

Hindi. Ang cost per token ay hourly price na hinati sa aktuwal na dami ng tokens na nagawa ng server sa loob ng isang oras. Kaya kahit mabilis ang server, mataas pa rin ang cost per token kung halos buong araw itong idle. Utilization ang nagpapasya rito, hindi ang peak speed. Suriin din ang mga unit: ang nakalistang total token throughput ay maaaring kasama ang input tokens. Sa 1:1 input-to-output ratio, halos doble ito ng output rate. Kung naniningil din ng input tokens ang API na ikinukumpara mo, isama sa pagpepresyo ang parehong bahagi bago magkumpara.

Nakatulong ba ang artikulong ito?

#benchmarking#tokens-per-second#vllm#ollama#gpu-vps