วิธีวัดค่า Tokens per second บน Local LLM อย่างแม่นยำ
การเช่า GPU จะคุ้มค่ากว่าจ่ายราย token ก็ต่อเมื่อมีปริมาณงานสูงเกินเกณฑ์ที่กำหนด เรียนรู้วิธีวัดค่า throughput ด้วยการทำ concurrency sweep เพื่อตัดสินใจเลือกโครงสร้างพื้นฐานให้เหมาะสม
เหตุผลที่ tokens per second เป็นตัวตัดสินความคุ้มค่าของ GPU
Tokens per second คืออัตราที่เซิร์ฟเวอร์ของคุณสร้างข้อความเอาต์พุต และเป็นตัวเลขที่ใช้ตัดสินว่าการเช่า GPU นั้นถูกกว่าการจ่ายค่า API แบบราย token หรือไม่ โดย GPU จะถูกคิดค่าบริการเป็นรายชั่วโมงไม่ว่าเครื่องจะทำงานอยู่หรือว่างงาน ในขณะที่ API แบบ hosted จะคิดค่าบริการตามจำนวน token ดังนั้น GPU จะคุ้มค่าก็ต่อเมื่อคุณมีอัตราการสร้างเอาต์พุตที่สูงพอตลอดระยะเวลาส่วนใหญ่ที่คุณจ่ายเงินไป
นั่นหมายความว่าคุณจำเป็นต้องมีการวัดผลจริง ไม่ใช่เพียงตัวเลขที่อ่านมาจากที่อื่น หน้านี้จะกำหนดตัวเลข 4 ค่าที่ควรบันทึกไว้ พร้อมทั้งระบุคำสั่งที่ใช้สร้างตัวเลขเหล่านั้น และวิธีคำนวณเพื่อนำไปสู่การตัดสินใจ
เหตุใดตัวเลข tokens per second ที่เผยแพร่จึงไม่ใช่ตัวเลขของคุณ
DigitalOcean ได้เผยแพร่ตัวเลข throughput ในเดือนกรกฎาคม 2026 สำหรับ NVIDIA H200 หนึ่งตัวที่รัน llama3.3-70b-instruct ในรูปแบบ FP8 (8-bit floating point) บน vLLM ตัวเลขเหล่านี้มีประโยชน์แต่ไม่ใช่ตัวเลขของคุณ
ข้อมูลเบื้องหลังแผนภูมินี้
[
{
"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"
}
]ทุกแถวข้างต้นอ้างอิงมาจากหน้านั้น และสองแถวเป็นค่าต่ำสุดของช่วงที่ระบุไว้ ดังนั้นให้อ่านค่าทั้งสองนั้นเป็นค่าพื้นฐาน ไม่มีข้อมูลใดในตารางนี้ที่เราเป็นผู้ตรวจวัดเอง
เริ่มจากสองแถวสุดท้าย หัวข้อหลักคือ 4,071.6 tok/s ในขณะที่อัตราเฉพาะ output คือ 2,036 tok/s หัวข้อหลักนับรวมทั้ง input และ output tokens เข้าด้วยกัน การทดสอบนั้นใช้ input 1,024 tokens เทียบกับ output 1,024 tokens ดังนั้นเกือบครึ่งหนึ่งของหัวข้อหลักคือ output การแยกส่วนนี้มีความสำคัญเพราะ output คือส่วนที่ช้ากว่า Prefill (การอ่าน prompt) จะประมวลผล input tokens ทั้งหมดในรอบเดียว ส่วน Decode (การเขียนคำตอบ) จะสร้างทีละหนึ่ง token หัวข้อหลักของ throughput รวมจึงเป็นการหาค่าเฉลี่ยระหว่างตัวเลขที่ประมวลผลได้ง่ายกับตัวเลขที่ใช้ทรัพยากรสูง
มาดูแถวแรก H200 ตัวเดียวกันที่ให้บริการทีละหนึ่งคำขอสร้างได้ 47 tok/s ดังนั้นตัวเลขเมื่อระบบทำงานเต็มประสิทธิภาพ (saturated) จึงสูงกว่าถึงกว่าสี่สิบเท่าบนฮาร์ดแวร์เดียวกัน ช่องว่างนี้เกิดขึ้นเพราะขั้นตอนการ decode เพียงขั้นตอนเดียวทำให้ GPU ต้องรอหน่วยความจำเกือบตลอดเวลา และการมีคำขอพร้อมกันหลายรายการจะช่วยเติมเต็มเวลาที่ว่างนั้น แถวที่สองคือ 236 tok/s ซึ่งเป็น H100 ตัวเดียวบนโมเดลเดียวกัน ถูกจำกัดด้วย KV cache (key and value cache ซึ่งเป็นหน่วยความจำต่อคำขอที่การสนทนาที่กำลังให้บริการเก็บไว้บนการ์ด) การ์ดขนาด 80 GB รองรับคำขอพร้อมกันได้น้อยกว่าสำหรับโมเดลขนาด 70B จึงทำให้จุดอิ่มตัวต่ำกว่า
หากเปลี่ยนโมเดลหรือเปลี่ยนอัตราส่วน input ต่อ output ตัวเลขข้างต้นทั้งหมดจะเปลี่ยนไป ตัวเลขที่เผยแพร่เป็นเพียงการกำหนดความคาดหวังของคุณ ไม่ใช่การกำหนดงบประมาณของคุณ ซึ่งเป็นกฎเดียวกับที่ใช้ในการ ทำ benchmarking VPS อย่างตรงไปตรงมา ทั้งในส่วนของดิสก์และเครือข่าย
ตัวเลขสี่ประการที่สำคัญ
- Time to first token (TTFT): ระยะเวลาระหว่างการส่งคำขอจนถึงโทเค็นแรกที่ได้รับกลับมา ซึ่งประกอบด้วยเวลาในการประมวลผลล่วงหน้า (prefill) และเวลาในคิว ผู้ใช้งานจะสัมผัสถึงค่านี้ได้โดยตรง
- Output tokens per second (ต่อสตรีม): ความเร็วในการเขียนคำตอบหลังจากเริ่มแสดงผลแล้ว หากความเร็วสูงกว่า 20 tok/s จะถือว่าเร็วกว่าความเร็วในการอ่านของคนส่วนใหญ่ ดังนั้นการเพิ่มความเร็วในส่วนนี้จึงให้ผลตอบแทนน้อย
- Saturated total output throughput: ผลรวมของปริมาณงานจากทุกสตรีมที่ทำงานพร้อมกันเมื่อเซิร์ฟเวอร์รับโหลดเต็มที่ นี่คือตัวเลขที่บ่งบอกถึงขีดความสามารถของระบบและเป็นตัวเลขที่สะท้อนถึงความคุ้มค่าของค่าใช้จ่ายด้าน GPU
- p50 และ p99 TTFT ภายใต้สภาวะที่มีการใช้งานพร้อมกัน: p50 คือค่าของคำขอที่อยู่ตรงกลาง ส่วน p99 คือค่าที่คำขอ 99 จาก 100 รายการจะได้รับผลลัพธ์ภายในระยะเวลานี้ การรอคิวจะปรากฏให้เห็นในค่า p99 ก่อนเสมอ
ตัวเลขสองค่าแรกจะดีขึ้นเมื่อเซิร์ฟเวอร์มีภาระงานน้อย ส่วนค่าที่สามจะดีขึ้นเมื่อเซิร์ฟเวอร์มีภาระงานสูง ตัวเลขเหล่านี้มีผลกระทบที่ขัดแย้งกัน จึงไม่มีตัวเลขเพียงค่าเดียวที่สามารถอธิบายประสิทธิภาพของเครื่องเซิร์ฟเวอร์ได้ทั้งหมด
แก้ไขความยาวของอินพุตและเอาต์พุตก่อนเริ่มการวัดผล
Throughput ขึ้นอยู่กับรูปแบบของ traffic งานที่มี prompt 4,000 token และคำตอบ 50 token ถือเป็นงานที่เน้น prefill ในขณะที่งานที่มี prompt 200 token และคำตอบ 2,000 token ถือเป็นงานที่เน้น decode เซิร์ฟเวอร์เดียวกันจะแสดงค่า tokens per second ที่แตกต่างกันอย่างมากสำหรับงานทั้งสองประเภทนี้ ดังนั้นให้เลือกอัตราส่วนมาหนึ่งค่า บันทึกค่านี้ไว้ข้างตัวเลขทุกตัวที่คุณจด และห้ามนำค่าที่มาจากอัตราส่วนต่างกันมาเปรียบเทียบกัน ค่าอินพุต 1,024 และเอาต์พุต 1,024 เป็นค่าเริ่มต้นที่เหมาะสมเนื่องจากผู้ให้บริการหลายรายเผยแพร่ผลการทดสอบที่อัตราส่วนนี้ หากคุณทราบลักษณะ traffic จริงของคุณ ให้ใช้ค่าจาก traffic จริงนั้น
กำหนดความยาวของเอาต์พุตให้คงที่ด้วย โมเดลที่หยุดทำงานหลังจากสร้างไปได้ 60 token จะให้ผลลัพธ์การรันที่สั้นกว่า ซึ่งไม่สามารถนำไปเปรียบเทียบกับการรันเต็มรูปแบบได้ เนื่องจาก TTFT จะกลายเป็นสัดส่วนที่ใหญ่ขึ้นในการรันนั้น ซึ่งจะฉุดค่า output throughput ให้ต่ำลงตามวิธีการคำนวณของ benchmark แม้ว่าแต่ละคำขอจะเสร็จสิ้นเร็วขึ้นก็ตาม แฟล็ก --ignore-eos ใน vLLM benchmark client จะบังคับให้ทุกคำขอสร้างจำนวน token ตามที่กำหนดไว้พอดี ทำให้การรันสองครั้งสามารถเปรียบเทียบกันได้ การเลือกโมเดลส่งผลต่อตัวเลขเหล่านี้มากกว่าการใช้แฟล็กใดๆ โดยเนื้อหา การติดตั้งโมเดล Qwen 3 ลงบน VPS GPU ตัวเดียว จะครอบคลุมถึงแง่มุมด้านหน่วยความจำในการตัดสินใจเลือกดังกล่าว
วัดค่าจากสตรีมเดียวเป็นอันดับแรก
เริ่มต้นด้วยกรณีที่ง่ายที่สุด นี่คือการตรวจสอบความถูกต้องเบื้องต้นและเป็นค่าขีดจำกัดสูงสุด Ollama จะแสดงเวลาการทำงานของตัวเองออกมา
ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."บรรทัดที่ต้องอ่านคือ eval rate ซึ่งเป็นจำนวนโทเค็นที่สร้างได้ต่อวินาที prompt eval rate คืออัตราการประมวลผลช่วงแรก (prefill rate) และ load duration คือเวลาที่ใช้ในการโหลดโมเดลเข้าสู่ VRAM ในการเรียกใช้งานครั้งแรกหลังจากเริ่มระบบใหม่ load duration จะมีค่าสูง ทำให้ค่า total duration อาจทำให้เข้าใจผิดได้ ให้รันคำสั่งสองครั้งแล้วอ่านผลลัพธ์จากครั้งที่สอง โดยปกติ Ollama จะยกเลิกการโหลดโมเดลที่ไม่ได้ใช้งานหลังจากผ่านไปห้านาที ดังนั้นการเว้นช่วงนานเกินไประหว่างการรันจะทำให้คุณกลับไปอยู่ในสถานะเริ่มระบบใหม่ (cold case) อีกครั้ง
ฟิลด์เดียวกันนี้สามารถดึงมาจาก API ซึ่งเขียนสคริปต์จัดการได้ง่ายกว่า
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 มีหน่วยเป็นนาโนวินาที ดังนั้นการหารด้วย 1,000,000,000 จะได้ค่าเป็นวินาที การหารดังกล่าวเป็นวิธีที่เอกสาร API ของ Ollama กำหนดไว้สำหรับการคำนวณโทเค็นต่อวินาที หากเซิร์ฟเวอร์ยังไม่พร้อมใช้งาน การโฮสต์ LLM ด้วยตนเองโดยใช้ Ollama บน VPS จะครอบคลุมขั้นตอนการติดตั้งและหน่วย systemd
ค่า TTFT จำเป็นต้องใช้การร้องขอแบบสตรีมมิ่ง ซึ่ง 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 คือช่วงเวลาที่ไบต์แรกของเนื้อหาการตอบกลับมาถึง ในการทำ chat completion แบบสตรีมมิ่ง ไบต์นั้นจะเป็นส่วนหนึ่งของ server-sent event แรก ซึ่งอาจเป็นโทเค็นเนื้อหาตัวแรกหรือส่วนต่าง (delta) ของบทบาทที่ส่งมาก่อนหน้า ดังนั้นให้ถือว่าค่านี้คือ TTFT โดยบวกลบหนึ่งอีเวนต์ ซึ่งมีความแม่นยำเพียงพอสำหรับการเปรียบเทียบการรันสองครั้งบนเซิร์ฟเวอร์เดียวกัน
ตัวเลขจากสตรีมเดียวนั้นแสดงประสิทธิภาพของเครื่องในแง่บวกเกินจริง ค่า TTFT จะเป็นค่าที่ดีที่สุดเท่าที่จะเป็นไปได้เพราะไม่มีคิวงานอื่นรออยู่ข้างหน้า และอัตราต่อสตรีมก็จะเป็นค่าที่ดีที่สุดเพราะการ์ดจอทั้งใบกำลังประมวลผลเพียงคำขอเดียว ทั้งสองค่านี้ไม่ได้บ่งบอกถึงขีดความสามารถในการรองรับงานจริงของเครื่อง
คุณจะทำการทดสอบ Concurrency Sweep ได้อย่างไร
การทำ Sweep คือการรัน Workload ชุดเดิมซ้ำๆ โดยเพิ่มระดับ Concurrency ขึ้นเรื่อยๆ เพื่อบันทึกผลลัพธ์ที่เกิดขึ้นในแต่ละขั้นตอน vLLM มี client สำหรับงานนี้มาให้ในตัว ซึ่งรองรับ OpenAI API ดังนั้นจึงสามารถใช้กับ Ollama หรือบริการอื่นที่รองรับมาตรฐาน 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 ใช้สำหรับจำกัดจำนวนคำขอที่กำลังประมวลผลอยู่ (requests in flight) และเป็นตัวแปรที่คุณต้องปรับเปลี่ยนในการทำ Sweep ส่วน --num-prompts คือจำนวนคำขอทั้งหมดที่ส่งไป ดังนั้นควรตั้งค่าให้มากกว่า Concurrency ประมาณ 10 เท่าเพื่อให้ได้ค่าเฉลี่ยที่เสถียร ข้อมูลสรุปจะแสดง Output token throughput (tok/s): และ Total token throughput (tok/s): ตามด้วย Mean TTFT (ms):, Median TTFT (ms): และ P99 TTFT (ms): ภายใต้หัวข้อ Time to First Token
แม้ในผลลัพธ์จะไม่มีอัตราต่อ Stream แสดงไว้โดยตรง แต่สามารถคำนวณได้ด้วยการหาร Mean TPOT (ms): คือเวลาเฉลี่ยต่อ Output Token หลังจาก Token แรก ดังนั้นหากได้ 25 ms ต่อ Token จะเท่ากับ 40 Tokens ต่อวินาทีต่อ Stream การนำ Output Throughput หารด้วย Concurrency ก็จะได้ผลลัพธ์เดียวกัน
จากนั้นให้ทำซ้ำเป็นลูปและบันทึกผลลัพธ์ของแต่ละรอบไว้
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 ที่บันทึกไว้
เนื่องจากแต่ละรอบจะเขียนไฟล์แยกกัน คุณจึงสามารถดึงเฉพาะฟิลด์ที่ต้องการจากทุกไฟล์ออกมาพร้อมกันได้
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 ค่านี้จะใกล้เคียงกับสองเท่า p99_ttft_ms จะปรากฏอยู่แม้ไม่มี --metric-percentiles เพราะ Flag ดังกล่าวมีค่าเริ่มต้นเป็น 99 เลข 50 ในคำสั่งคือสิ่งที่เพิ่ม p50_ttft_ms เข้าไปข้างๆ median_ttft_ms ซึ่งเป็นค่าที่ทุก Metric ใน --percentile-metrics จะได้รับ หากคุณระบุ Percentile ที่ไม่ได้ตั้งค่าไว้ เช่น .p90_ttft_ms โปรแกรม jq จะแสดงผลเป็น null
การทำ 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 แถวนั้นเป็นเพียงตัวอย่างที่แสดงให้เห็นถึงรูปแบบที่ได้จากการทำ sweep บน GPU box ขนาดเล็กที่เช่าใช้งานทั่วไป โดยเป็นตัวเลขในระดับที่สมเหตุสมผล ข้อมูลเหล่านี้ไม่ใช่การวัดผลจากเซิร์ฟเวอร์ของคุณและไม่ใช่ตัวเลขจากผู้ให้บริการ ให้คุณรันลูปด้านบนและแทนที่ด้วยข้อมูลของคุณเอง
จงอ่านรูปแบบของผลลัพธ์ เพราะรูปแบบนี้คือสิ่งที่นำไปประยุกต์ใช้ในภาพรวมได้ ในกรณีที่มี 1 stream ทั้งระบบจะผลิตโทเค็นได้ 92 โทเค็นต่อวินาที โดยมีค่า p99 TTFT อยู่ที่ 61 ms เมื่อถึงระดับ 128 streams ปริมาณรวมจะเพิ่มขึ้นเป็น 2304 โทเค็นต่อวินาที ซึ่งสูงขึ้นถึง 25 เท่า ในขณะที่แต่ละ stream จะลดลงเหลือ 18 โทเค็นต่อวินาที และค่า p99 TTFT จะพุ่งไปถึง 3820 ms ปริมาณ throughput รวมที่เพิ่มขึ้นเป็นเพราะการทำ batching ช่วยเปลี่ยนช่วงเวลาที่หน่วยความจำว่างงานให้กลายเป็นงานที่มีประโยชน์ ส่วนความเร็วต่อ stream ที่ลดลงเป็นเพราะทรัพยากรการประมวลผลถูกแบ่งใช้งานร่วมกัน
การเพิ่มจำนวนขึ้นเป็นสองเท่าในครั้งสุดท้ายคือจุดที่บ่งบอกสถานะ การเพิ่มจาก 64 เป็น 128 streams ทำให้ throughput รวมเพิ่มขึ้นไม่ถึงร้อยละ 6 ในขณะที่ค่า p99 TTFT เพิ่มขึ้นเกือบ 3 เท่า ซึ่งหมายความว่าคำขอต่างๆ กำลังเข้าคิวแทนที่จะได้รับการประมวลผล อาจเป็นเพราะ KV cache เต็ม หรือเซิร์ฟเวอร์ถึงขีดจำกัดการจัดตารางเวลา (scheduling cap) เช่น max_num_seqs ของ vLLM จุดปฏิบัติงานที่เหมาะสมควรอยู่ก่อนหน้านั้น คือที่ 32 streams ซึ่งระบบยังคงทำได้ 1728 โทเค็นต่อวินาที หรือคิดเป็นร้อยละ 75 ของจุดสูงสุด โดยได้ความเร็ว 54 โทเค็นต่อวินาทีต่อ stream และมีค่า p99 TTFT อยู่ที่ 498 ms ให้ใช้จุดนั้นเป็นค่าความจุของระบบคุณ จุดสูงสุดของกราฟเป็นเพียงตัวเลขที่คุณไม่สามารถนำมาใช้ให้บริการผู้ใช้จริงได้
Ollama และ vLLM ไม่ได้วัดค่าสิ่งเดียวกัน
หากคุณรันการทดสอบ sweep กับเซิร์ฟเวอร์ Ollama ค่าเริ่มต้น ผลลัพธ์รวมจะแทบไม่เปลี่ยนแปลง เนื่องจาก OLLAMA_NUM_PARALLEL ถูกตั้งค่าเริ่มต้นไว้ที่ 1 ทำให้มีเพียงหนึ่งคำขอที่ทำงานในขณะที่คำขออื่นต้องรอคิว ซึ่งคิวนี้เองที่ทำให้ค่า p99 TTFT สูงขึ้นในขณะที่ผลลัพธ์รวมยังคงที่ คุณต้องเพิ่มค่านี้ก่อนที่จะทำการวัดผลใดๆ
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=8"ให้รีสตาร์ทด้วย sudo systemctl restart ollama จากนั้นตรวจสอบว่าโมเดลยังคงโหลดได้พอดีกับหน่วยความจำ แต่ละ parallel slot จะได้รับส่วนแบ่งของ context window ของตัวเอง ดังนั้นเอกสารของ Ollama จึงระบุว่า context ขนาด 2K ที่มี 4 parallel requests จะใช้พื้นที่รวม 8K หากคุณเพิ่มจำนวน slot มากเกินไป โมเดลจะล้นออกจาก VRAM ให้ตรวจสอบที่ ollama ps หากคอลัมน์ PROCESSOR แสดงค่าประมาณ 48%/52% CPU/GPU หมายความว่าโมเดลบางส่วนถูกย้ายไปทำงานบน CPU ซึ่งจะทำให้ throughput ลดลงแทนที่จะเพิ่มขึ้นเมื่อคุณเพิ่มระดับ concurrency หลังจากเต็มจำนวน parallel slots แล้ว คำขอจะถูกนำไปต่อคิวที่ OLLAMA_MAX_QUEUE ซึ่งค่าเริ่มต้นคือ 512 หลังจากนั้นเซิร์ฟเวอร์จะตอบกลับด้วยสถานะ 503
vLLM ใช้เทคนิค continuous batching จึงสามารถรับคำขอใหม่เข้าสู่ batch ที่กำลังทำงานอยู่ได้ทันทีเมื่อมี slot ว่าง กราฟประสิทธิภาพของ vLLM จะไต่ระดับขึ้นเรื่อยๆ จนกว่าทรัพยากรจะหมด ซึ่งโดยปกติคือ KV cache แม้ว่าการกำหนดค่าจำกัด เช่น max_num_seqs หรือภาระงานในการจัดตารางเวลาของ CPU อาจทำให้กราฟแบนราบเร็วกว่านั้น Ollama ถูกปรับแต่งมาเพื่อเน้นการใช้งานหนึ่งโมเดลต่อหนึ่งเครื่องและติดตั้งง่าย ดังนั้นเอนจินทั้งสองจึงให้คำตอบที่แตกต่างกันในการทดสอบ sweep เดียวกัน ซึ่งเป็นหัวข้อหลักของ การเปรียบเทียบ Ollama และ vLLM ในฐานะเอนจินสำหรับให้บริการ โปรดบันทึกว่าตัวเลขแต่ละชุดมาจากเอนจินใดและเวอร์ชันใดเสมอ
ห้าวิธีในการวัดผลที่ผิดพลาด
- ไคลเอนต์อยู่ไกลเกินไป การทำ Benchmarking จากแล็ปท็อปของคุณผ่านอินเทอร์เน็ตจะเพิ่มเวลา Round trip เข้าไปในทุกค่า TTFT ทำให้คุณกำลังวัดประสิทธิภาพการเชื่อมต่ออินเทอร์เน็ตที่บ้านของคุณเอง ให้รันไคลเอนต์ในภูมิภาคเดียวกับเซิร์ฟเวอร์แทน
- โมเดลยังไม่พร้อมใช้งาน (Cold) คำขอแรกจะต้องเสียเวลาโหลด Weight และใน vLLM อาจต้องเสียเวลาทำ Graph capture ด้วย ให้ส่งชุดข้อมูลสำหรับ Warmup ไปก่อนแล้วทิ้งผลลัพธ์นั้นไป
- Prefix caching ช่วยตอบคำถามแทนคุณ vLLM เปิดใช้งาน Prefix caching อัตโนมัติเป็นค่าเริ่มต้น ดังนั้นการส่ง Prompt เดิมซ้ำๆ จะเป็นการวัดประสิทธิภาพของ Cache แทนที่จะเป็น Prefill ทำให้ค่า TTFT ลดลงจนเหลือเพียงเศษเสี้ยวของความเป็นจริง
--dataset-name randomช่วยหลีกเลี่ยงปัญหานี้ได้เนื่องจากทุก Prompt มีความแตกต่างกัน เพื่อความมั่นใจ ให้เริ่มเซิร์ฟเวอร์ด้วย--no-enable-prefix-caching - ผลลัพธ์สั้นเกินไป สำหรับคำตอบที่มีความยาว 32 token ค่า TTFT จะครอบงำเวลาของแต่ละคำขอ และค่า Tokens per second ที่คุณได้จะเป็นเพียงการวัดประสิทธิภาพของ Prefill เท่านั้น ให้ใช้
--ignore-eosร่วมกับความยาวผลลัพธ์ที่สมจริง - คุณรายงานเฉพาะค่า Concurrency 1 ค่านี้ให้ผลลัพธ์ TTFT ที่ดูดีที่สุดในตาราง และจะเป็นข้อมูลต้นทุนที่ถูกต้องก็ต่อเมื่อคำขอจริงของคุณไม่มีการซ้อนทับกันเลย หากคำขอมีการซ้อนทับกัน ต้นทุนจะขึ้นอยู่กับ Throughput ที่คุณรักษาไว้ได้ภายใต้ระดับ Concurrency ที่เกิดขึ้นจริงจาก Traffic ของคุณ ดังนั้นควรวัดผลที่จุดนั้นด้วย
เปลี่ยนตัวเลขที่วัดได้ให้เป็นการตัดสินใจ
นำค่า Output Throughput ที่ได้จากการทำ Sweep ณ ระดับ Concurrency ที่ตรงกับปริมาณ Traffic จริงของคุณ มาเปรียบเทียบกับราคาต่อ Token นี่จะเป็นตัวเลขที่จุดอิ่มตัว (Saturated) ก็ต่อเมื่อมีคำขอมากพอที่จะทำให้ Batch เต็มตลอดเวลา หาก Workload ส่งคำขอทีละรายการ คุณต้องใช้ค่าอัตราต่อ Single-stream แทน จุดคุ้มทุน (Break-even) สามารถหาได้จากการหาร เมื่อคุณคำนวณราคาของ Input Tokens ที่เข้ามาพร้อมกับ 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ลองคำนวณโดยใช้ราคาของ DigitalOcean ในเดือนกรกฎาคม 2026 โดย Inference Endpoint แบบเฉพาะ (Dedicated) รุ่น H200 มีราคา 4.47 ดอลลาร์ต่อชั่วโมง และบริการ Serverless Llama 3.3 70B มีราคา 0.65 ดอลลาร์ต่อล้าน Token สำหรับ Input และ 0.65 ดอลลาร์ต่อล้าน Token สำหรับ Output ที่อัตราส่วน 1:1 ตามที่ใช้ข้างต้น ทุกๆ ล้าน Output Tokens จะมี Input Tokens ติดมาด้วยหนึ่งล้าน ดังนั้นราคาที่แท้จริงคือ 1.30 ดอลลาร์ต่อล้าน Output Tokens ดังนั้น 4.47 หารด้วย 1.30 จะได้ประมาณ 3.44 ล้าน Output Tokens ต่อชั่วโมง และเมื่อหารด้วย 3,600 วินาที จะได้ประมาณ 955 Output Tokens ต่อวินาที หรือประมาณ 1,910 Tokens ต่อวินาทีหากนับรวมทั้ง Input และ Output ราคาเหล่านี้เป็นราคาของพวกเขา ส่วนการหารเป็นของเรา เมื่อเราตรวจสอบในวันที่ 25 ตุลาคม 2026 พบว่า H200 Endpoint ยังคงราคา 4.47 ดอลลาร์ต่อชั่วโมง แต่ DigitalOcean ได้ยกเลิกบริการ Serverless Llama 3.3 70B ไปเมื่อวันที่ 18 สิงหาคม 2026 และแนะนำให้ผู้ใช้ไปใช้ Llama 4 Maverick ซึ่งมีราคา 0.25 ดอลลาร์ต่อล้าน Input Tokens และ 0.87 ดอลลาร์ต่อล้าน Output Tokens เนื่องจากเป็นโมเดลที่ต่างออกไป จึงจำเป็นต้องทำ Sweep ใหม่ก่อนที่จะนำมาเปรียบเทียบกันได้
คำสำคัญที่ใช้ตัดสินใจเรื่องนี้คือ ความต่อเนื่อง (Sustained) การทำได้ 955 Output Tokens ต่อวินาทีที่จุดอิ่มตัวเป็นเวลาสองชั่วโมงต่อวัน ไม่ได้หมายความว่าคุณทำได้ 955 Output Tokens ต่อวินาทีอย่างต่อเนื่อง เพราะคุณต้องจ่ายเงินสำหรับอีกยี่สิบสองชั่วโมงที่เหลือด้วย การเช่าการ์ดจอในรูปแบบ GPU Droplet ไม่ได้ช่วยให้เกณฑ์นี้ต่ำลง ในวันที่ 25 ตุลาคม 2026 ราคา Droplet ของ DigitalOcean ระบุว่า H200 มีราคา 4.47 ดอลลาร์ต่อชั่วโมงแบบ On-demand ซึ่งเท่ากับราคา Endpoint ส่วน NVIDIA Droplet รุ่นที่ถูกที่สุดอย่าง RTX 4000 ที่ราคา 0.76 ดอลลาร์ต่อชั่วโมง และ L40S หรือ RTX 6000 ที่ราคา 1.57 ดอลลาร์ต่อชั่วโมงนั้น มีขนาดเล็กเกินกว่าจะรันโมเดล 70B ในรูปแบบ FP8 ได้ ดังนั้นจากตัวเลขข้างต้น H200 ที่อิ่มตัวที่ 2,036 Output Tokens ต่อวินาที จะต้องทำประสิทธิภาพให้ได้เฉลี่ยประมาณ 47 เปอร์เซ็นต์ของจุดสูงสุดนั้นตลอดทุกชั่วโมงที่คุณจ่ายเงิน เพื่อให้คุ้มกับราคา 0.65 ดอลลาร์ต่อล้าน Token และหากต่ำกว่านั้น ราคาแบบต่อ Token จะคุ้มค่ากว่า ชั่วโมงที่ GPU ว่างงาน (Idle GPU hours) ไม่ใช่ความเร็วของ Token คือสิ่งที่มักทำให้การทำ Self-hosting ไม่คุ้มทุน
ดังนั้นการตัดสินใจของคุณจึงมีปัจจัยนำเข้าสองอย่าง Sweep จะให้ค่าเพดานสูงสุดแก่คุณ ส่วนรูปแบบ Traffic จะบอกสัดส่วนของเพดานนั้นที่คุณใช้งานจริง ให้นำตัวเลขมาคูณกัน จากนั้นนำผลลัพธ์ไปดูที่ จุดคุ้มทุนระหว่าง GPU VPS กับ API แบบจ่ายตามจริง เพื่ออ่านคำตอบสำหรับปริมาณงานของคุณ
FAQ
ค่า tokens per second ที่เหมาะสมสำหรับ LLM ที่โฮสต์เองคือเท่าใด
คำตอบมีสองแง่มุม เนื่องจากตัวชี้วัดนี้ทำหน้าที่สองอย่าง สำหรับผู้ใช้งานที่อ่านผลลัพธ์ ค่าที่สูงกว่าประมาณ 20 tokens ต่อวินาทีต่อสตรีมถือว่าเร็วกว่าความเร็วในการอ่านแล้ว ดังนั้นค่าที่สูงกว่านี้จึงไม่ได้ช่วยอะไรเพิ่มเติม ในแง่ของต้นทุน ตัวเลขที่สำคัญคือปริมาณ throughput รวมที่คุณสามารถรักษาไว้ได้ภายใต้ภาระงานจริงของคุณ คำว่า "เหมาะสม" จึงหมายถึงค่าที่ทำให้คุณถึงจุดคุ้มทุน เมื่อเทียบกับราคา $0.65 ต่อล้าน tokens ทั้งขาเข้าและขาออก บนเซิร์ฟเวอร์ที่มีค่าใช้จ่าย $4.47 ต่อชั่วโมง จุดคุ้มทุนจะอยู่ที่ประมาณ 955 tokens ต่อวินาทีที่อัตราส่วน 1:1 ตามราคา ณ เดือนกรกฎาคม 2026 สตรีมเดียวบนโมเดลขนาดใหญ่ไม่มีทางทำความเร็วถึงระดับนี้ได้ ซึ่งเป็นเหตุผลว่าทำไมจึงต้องมีการทำ batching
ทำไม throughput ของ Ollama ถึงคงที่เมื่อเพิ่มจำนวน concurrent requests
OLLAMA_NUM_PARALLEL มีค่าเริ่มต้นเป็น 1 ทำให้เซิร์ฟเวอร์ประมวลผลทีละคำขอต่อหนึ่งโมเดลและนำคำขอที่เหลือเข้าคิวไว้ สูงสุดถึง OLLAMA_MAX_QUEUE (ค่าเริ่มต้นคือ 512) ก่อนที่จะส่งสถานะ 503 กลับไป ปริมาณ output รวมจึงคงที่ในขณะที่ค่า p99 TTFT เพิ่มสูงขึ้น ซึ่งเป็นสัญญาณบ่งบอกถึงการรอคิวแทนที่จะเป็น GPU ที่ทำงานหนักเกินไป ให้ตั้งค่าตัวแปรนี้ใน systemd drop-in แล้วรีสตาร์ท จากนั้นตรวจสอบ ollama ps เนื่องจากแต่ละ parallel slot จะเพิ่มการใช้ context ที่จัดสรรไว้และอาจผลักภาระบางส่วนของโมเดลไปที่ CPU ได้
ควรวัดค่า time to first token หรือ tokens per second
ควรวัดทั้งสองค่า เนื่องจากทั้งสองค่าจะเปลี่ยนแปลงไปในทิศทางตรงกันข้ามเมื่อภาระงานเพิ่มขึ้น TTFT คือสิ่งที่ผู้ใช้สัมผัสได้ ส่วน throughput ของ output ที่อิ่มตัวคือสิ่งที่สะท้อนอยู่ในใบแจ้งหนี้ของคุณ ให้บันทึกค่า p50 และ p99 TTFT ในทุกระดับของ concurrency จากนั้นเลือกค่า concurrency สูงสุดที่ค่า p99 TTFT ยังอยู่ในระดับที่คุณยอมรับได้ แล้วรายงานค่า throughput ณ จุดนั้นว่าเป็นความจุของคุณ ไม่ใช่ค่าสูงสุดที่จุดยอดของกราฟ
ค่า tokens per second ที่สูงกว่าหมายถึงต้นทุนต่อ token ที่ต่ำกว่าเสมอไปหรือไม่
ไม่เสมอไป ต้นทุนต่อ token คือราคาต่อชั่วโมงหารด้วยจำนวน tokens ที่เซิร์ฟเวอร์ผลิตได้จริงในชั่วโมงนั้น ดังนั้นเซิร์ฟเวอร์ที่เร็วแต่ปล่อยให้ว่างงานเกือบทั้งวันก็ยังมีต้นทุนต่อ token ที่สูงอยู่ดี การใช้งานจริง (utilisation) เป็นตัวตัดสิน ไม่ใช่ความเร็วสูงสุด นอกจากนี้ให้สังเกตหน่วยด้วย: ค่า total token throughput ที่ระบุไว้มักนับรวม input tokens ด้วย ดังนั้นที่อัตราส่วน input ต่อ output เป็น 1:1 ค่านี้จะใกล้เคียงกับสองเท่าของอัตรา output หาก API ที่คุณนำมาเปรียบเทียบคิดเงินทั้ง input tokens และ output tokens ให้คำนวณราคาของทั้งสองส่วนก่อนทำการเปรียบเทียบ