ความแตกต่างระหว่าง Prefill และ Decode ในการรัน LLM
ทำความเข้าใจว่าทำไม Prefill จึงเป็น Compute bound ที่กำหนดค่า Time to first token และ Decode เป็น Memory bandwidth bound ที่กำหนดค่า Tokens per second พร้อมวิธีวัดผลแยกส่วน
ความแตกต่างระหว่าง Prefill และ Decode
ความแตกต่างระหว่าง Prefill และ Decode คือปัจจัยหลักที่อธิบายคำถามส่วนใหญ่เกี่ยวกับความหน่วง (latency) ของการรัน LLM (large language model) ด้วยตนเอง โดยขั้นตอน Prefill จะอ่าน prompt ทั้งหมดในรอบเดียวและถูกจำกัดด้วยพลังการประมวลผล (compute) ส่วนขั้นตอน Decode จะเขียนคำตอบทีละ token และถูกจำกัดด้วยแบนด์วิดท์ของหน่วยความจำ (memory bandwidth) ดังนั้น Time to first token จึงเป็นตัวเลขที่วัดจากช่วง Prefill ในขณะที่ Tokens per second เป็นตัวเลขที่วัดจากช่วง Decode ทั้งสองขั้นตอนทำงานบน GPU (graphics processing unit) เดียวกัน โดยใช้ weight ชุดเดียวกันและอยู่ในกระบวนการเดียวกัน จึงเป็นเรื่องปกติที่จะมองว่าทั้งสองเป็นภาระงาน (workload) เดียวกัน แต่ในความเป็นจริงแล้วทั้งสองมีพฤติกรรมเหมือนโปรแกรมสองโปรแกรมที่ใช้ทรัพยากรบนอุปกรณ์เดียวกัน หากแยกการพิจารณาทั้งสองส่วนออกจากกัน ผลลัพธ์ที่เคยดูสับสนก็จะมีความชัดเจนขึ้นทันที
เหตุใดขั้นตอน prefill จึงถูกจำกัดด้วยพลังการประมวลผล (compute bound)?
ขั้นตอน prefill จะส่ง prompt ทั้งหมดผ่านทุกเลเยอร์หนึ่งรอบ สำหรับ prompt ขนาด 2,000 token การคูณเมทริกซ์แต่ละครั้งจะมีงานให้ทำถึง 2,000 แถว ดังนั้น GPU จึงต้องคำนวณเลขจำนวนมากต่อข้อมูลน้ำหนัก (weight) แต่ละไบต์ที่โหลดเข้ามา อัตราส่วนระหว่างการคำนวณต่อไบต์ที่เคลื่อนย้ายนี้เรียกว่าความเข้มข้นของการคำนวณ (arithmetic intensity) ซึ่ง prefill มีค่านี้สูงมาก อุปกรณ์จึงทำงานใกล้ขีดจำกัดด้านการประมวลผลในขณะที่บัสหน่วยความจำยังมีทรัพยากรเหลือเฟือ
ขั้นตอน prefill สร้างผลลัพธ์สองอย่างคือ KV cache (เทนเซอร์ key และ value) สำหรับทุก token ใน prompt และ token แรกของผลลัพธ์ จะไม่มีข้อมูลใดส่งถึงผู้ใช้จนกว่าการประมวลผลรอบนี้จะเสร็จสิ้น นี่คือเหตุผลว่าทำไมบนเซิร์ฟเวอร์ที่ไม่มีโหลด prefill จึงเป็นส่วนประกอบหลักของเวลาในการสร้าง token แรก (TTFT) ทั้งนี้ TTFT ตามนิยามในคู่มือการทำ benchmarking ของ NVIDIA ยังรวมถึงเวลาในการรอคิวคำขอและความหน่วงของเครือข่ายด้วย ดังนั้นบนเซิร์ฟเวอร์ที่มีงานหนาแน่น เวลาที่รอในคิวอาจมีความสำคัญพอๆ กับตัว prompt เอง
ต้นทุนของ prefill จะเพิ่มขึ้นตามความยาวของ prompt โดยส่วนที่เป็นเส้นตรงคือการคำนวณเมทริกซ์ในแต่ละเลเยอร์ ส่วนที่เป็นกำลังสองคือการทำ attention ซึ่งแต่ละ token จะต้องประมวลผลร่วมกับทุก token ก่อนหน้า และจะเริ่มส่งผลชัดเจนเมื่อใช้ context ที่ยาว ดังนั้นการเพิ่มความยาว prompt เป็นสองเท่าจะทำให้เวลา prefill ใน TTFT เพิ่มขึ้นอย่างน้อยสองเท่า
คุณสามารถสังเกตปรากฏการณ์นี้ได้ภายในหนึ่งนาที โดยส่ง prompt ขนาด 200 token ไปยังเซิร์ฟเวอร์ของคุณ จากนั้นส่ง prompt ขนาด 2,000 token โดยขอให้สร้างจำนวน token ผลลัพธ์เท่ากันในแต่ละครั้ง คุณจะพบว่า TTFT เพิ่มขึ้นอย่างรวดเร็ว ในขณะที่ความเร็วในการสตรีมข้อมูลหลังจาก token แรกแทบจะไม่เปลี่ยนแปลงเลย
เหตุใดการถอดรหัส (decode) จึงถูกจำกัดด้วยแบนด์วิดท์หน่วยความจำ?
กระบวนการถอดรหัสจะสร้างโทเค็นหนึ่งตัวต่อหนึ่งขั้นตอน ในการสร้างโทเค็นนั้น GPU จำเป็นต้องอ่านค่าน้ำหนัก (weight) ทั้งหมดของโมเดลออกจากหน่วยความจำ นำค่าน้ำหนักแต่ละค่าไปคำนวณเพียงไม่กี่ครั้ง แล้วจึงทิ้งไป ความเข้มข้นของการคำนวณ (arithmetic intensity) จึงใกล้เคียงกับ 1 ทำให้หน่วยประมวลผลส่วนใหญ่ต้องเสียเวลาไปกับการรอคอย
การถอดรหัสทำงานช้าเนื่องจากโทเค็นแต่ละตัวจำเป็นต้องอ่านโมเดลทั้งหมดออกจากหน่วยความจำ ดังนั้นบัสหน่วยความจำจึงเป็นตัวกำหนดความเร็ว และทำให้หน่วยประมวลผลต้องว่างงาน
นั่นทำให้เพดานความเร็วของการถอดรหัสแบบสตรีมเดี่ยวเป็นค่าทางคณิตศาสตร์ที่คุณสามารถคำนวณได้บนกระดาษ โดยให้นำแบนด์วิดท์หน่วยความจำมาหารด้วยจำนวนไบต์ที่ค่าน้ำหนักเหล่านั้นใช้
ข้อมูลเบื้องหลังแผนภูมินี้
[
{
"device": "CPU, dual channel DDR5-5600",
"mem_bandwidth_gb_s": 90,
"decode_ceiling_tok_s": 6
},
{
"device": "NVIDIA A10G",
"mem_bandwidth_gb_s": 600,
"decode_ceiling_tok_s": 38
},
{
"device": "NVIDIA L40S",
"mem_bandwidth_gb_s": 864,
"decode_ceiling_tok_s": 54
},
{
"device": "NVIDIA RTX 4090",
"mem_bandwidth_gb_s": 1008,
"decode_ceiling_tok_s": 63
},
{
"device": "NVIDIA A100 80GB SXM",
"mem_bandwidth_gb_s": 2039,
"decode_ceiling_tok_s": 127
},
{
"device": "NVIDIA H100 SXM",
"mem_bandwidth_gb_s": 3350,
"decode_ceiling_tok_s": 209
}
]คอลัมน์แบนด์วิดท์แสดงค่าสเปกที่ผู้ผลิตแต่ละรายเผยแพร่ ส่วนคอลัมน์เพดานคือค่าดังกล่าวที่หารด้วย 16 GB ซึ่งเป็นขนาดของโมเดลที่มีพารามิเตอร์ 8 พันล้านตัวที่จัดเก็บด้วยความละเอียด 16 บิต นี่เป็นการคำนวณทางคณิตศาสตร์ ไม่ใช่ผลลัพธ์จากการทดสอบประสิทธิภาพ (benchmark) อัตราที่คุณวัดได้จริงจะต่ำกว่าค่านี้ และการทราบว่าต่ำกว่าเท่าใดนั้นมีประโยชน์ เพราะจะช่วยบอกคุณว่าควรปรับปรุง stack การให้บริการ (serving stack) หรือฮาร์ดแวร์ของคุณ
เมื่ออ่านแถว 6 แถวตามลำดับ คุณจะเห็นรูปแบบที่ชัดเจน CPU ที่ใช้ DDR5 แบบ dual channel จะมีความเร็วในการรับส่งข้อมูลประมาณ 90 GB/s ซึ่งจำกัดความเร็วการถอดรหัสไว้ที่ประมาณ 6 โทเค็นต่อวินาทีสำหรับโมเดลขนาดดังกล่าว ส่วน L40S จะอยู่ที่ประมาณ 54 สำหรับ H100 SXM ซึ่งมีแบนด์วิดท์ตามสเปกอยู่ที่ 3350 GB/s จะอยู่ที่ประมาณ 209
นี่คือเหตุผลที่การทำ quantization เป็นปัจจัยสำคัญที่สุดที่มีผลต่อความเร็วในการถอดรหัส หากคุณจัดเก็บค่าน้ำหนักชุดเดิมด้วยขนาด 8 บิตแทนที่จะเป็น 16 บิต คุณจะลดจำนวนไบต์ของค่าน้ำหนักที่ต้องอ่านต่อหนึ่งโทเค็นลงครึ่งหนึ่ง ทำให้เพดานความเร็วเพิ่มขึ้นประมาณสองเท่า อย่างไรก็ตาม เพดานนี้ไม่ใช่ผลลัพธ์สุดท้าย เนื่องจากยังต้องมีการอ่าน KV cache ตามขนาดจริงของมัน และรูปแบบ 8 บิตบางประเภทอาจเพิ่มภาระงานต่อโทเค็น เช่น การทำ dynamic per token activation quantization ที่ vLLM ระบุไว้สำหรับรูปแบบ FP8 บางตัว ดังนั้นอัตราที่วัดได้จริงจึงมักจะต่ำกว่า 2 เท่า ปัจจัยนี้ได้ผลด้วยเหตุผลเดียวกับที่เพดานความเร็วขยับขึ้น นั่นคือคุณได้ลดปริมาณการใช้งานหน่วยความจำลงนั่นเอง
ฉันจะวัดแต่ละเฟสบนเซิร์ฟเวอร์ของตัวเองได้อย่างไร?
Ollama จะส่งข้อมูลการแบ่งเฟสกลับมาในเนื้อหาของ response ให้ร้องขอการประมวลผลแบบไม่สตรีม (non-streaming completion) แล้วอ่านค่าจากตัวนับเหล่านั้น
curl -s http://localhost:11434/api/generate -d '{
"model": "llama3.2",
"prompt": "Explain memory bandwidth in two sentences.",
"stream": false
}' | jq '{prompt_eval_count, prompt_eval_duration, eval_count, eval_duration}'ให้ใช้แท็กของโมเดลที่คุณได้ดึงมาไว้แล้ว ซึ่งคำสั่ง ollama list จะแสดงให้คุณเห็น ส่วน prompt_eval_count และ prompt_eval_duration คือค่า prefill ได้แก่ จำนวน token ของ prompt และเวลาที่ใช้ไปตามลำดับ ส่วน eval_count และ eval_duration คือค่า decode ระยะเวลาจะแสดงเป็นหน่วยนาโนวินาที ดังนั้นความเร็วในการ decode คือ eval_count / eval_duration * 1e9 และความเร็วในการ prefill คือ prompt_eval_count / prompt_eval_duration * 1e9 เอกสารอ้างอิง API ของ Ollama ระบุว่า prompt_eval_duration จะครอบคลุมเฉพาะ token ของ prompt ที่ไม่ได้อยู่ในแคชเท่านั้น ดังนั้นให้คำนวณอัตรา prefill จาก prompt ที่เซิร์ฟเวอร์ยังไม่เคยเห็นมาก่อน คุณควรคาดหวังว่าอัตรา prefill จะสูงกว่าอัตรา decode ในคำขอเดียวกันอย่างมาก ช่องว่างระหว่างค่าทั้งสองนี้คือสิ่งที่เนื้อหาทั้งหมดในส่วนนี้อธิบายไว้
สำหรับเซิร์ฟเวอร์ที่รองรับ OpenAI API เช่น vLLM คุณสามารถใช้ curl เพื่อวัดเวลาจนกว่าจะได้รับไบต์แรกได้
curl -N -s -o /dev/null \
-w 'pretransfer %{time_pretransfer}s first_byte %{time_starttransfer}s\n' \
http://localhost:8000/v1/completions \
-H 'Content-Type: application/json' \
-d '{"model": "meta-llama/Llama-3.1-8B-Instruct", "prompt": "Explain memory bandwidth.", "max_tokens": 128, "stream": true}'time_starttransfer คือช่วงเวลาที่ไบต์แรกของเนื้อหามาถึง ดังนั้นเมื่อรวมกับ "stream": true จะได้ค่า TTFT รวมกับเวลาในการตั้งค่าการเชื่อมต่อ ให้ลบด้วย time_pretransfer เพื่อตัดต้นทุนในการตั้งค่าออกไป ให้รันคำสั่งสองครั้งและใช้ผลลัพธ์ครั้งที่สอง เนื่องจากครั้งแรกอาจรวมเวลาในการโหลดโมเดลแบบ cold start เข้าไปด้วย
นอกจากนี้ vLLM ยังเผยแพร่ข้อมูลการแบ่งเฟสในรูปแบบ Prometheus metrics ที่ /metrics ให้รัน curl -s http://localhost:8000/metrics | grep -E 'time_to_first_token|inter_token_latency' แล้วคุณจะได้รับ histogram ของ vllm:time_to_first_token_seconds และ vllm:inter_token_latency_seconds ให้เพิ่ม vllm:num_requests_running และ vllm:num_requests_waiting เพื่อดูความลึกของคิว และ vllm:kv_cache_usage_perc สำหรับแรงกดดันต่อแคช ทั้ง 5 ชื่อนี้คือองค์ประกอบทั้งหมดของแดชบอร์ด
ภายใต้สภาวะที่มีโหลด vllm bench serve --model <name> --num-prompts 200 --request-rate 4 จะทำหน้าที่ควบคุมเซิร์ฟเวอร์ที่กำลังทำงานอยู่และรายงานค่าเวลาจนถึง token แรก (time to first token) และค่าความหน่วงต่อ token ขาออก (per output token latency) พร้อมค่าเปอร์เซ็นไทล์ ซึ่งเป็นวิธีที่ตรงที่สุดในการดูว่าทั้งสองเฟสแย่งทรัพยากรกันอย่างไรบน stack ที่คุณใช้งานอยู่ เครื่องมือ GenAI-Perf และ LLMPerf ของ NVIDIA ก็สามารถวัดค่าปริมาณเหล่านี้ได้เช่นกันหากคุณต้องการใช้เครื่องมือแยกต่างหาก ก่อนที่คุณจะปรับแต่งค่าใดๆ ให้เก็บค่า baseline ที่สะอาดไว้ก่อน: วิธีการใน การวัดจำนวน token ต่อวินาทีบน LLM ในเครื่อง จะช่วยให้คุณได้ค่า baseline ที่คงอยู่แม้หลังจากรีบูตเครื่องแล้ว
เหตุใด system prompt ที่ยาวจึงทำให้ token แรกแสดงผลช้า แต่ไม่ส่งผลต่อความเร็วในการ streaming?
เนื่องจาก system prompt คือกระบวนการ prefill เพียงอย่างเดียว มันจะถูกประมวลผลเพียงครั้งเดียวในรอบเดียวกับส่วนที่เหลือของ prompt ก่อนที่ token แรกจะปรากฏขึ้น หลังจากผ่านรอบนั้นไปแล้ว มันจะคงอยู่เพียงในรูปแบบของ KV cache entries และในขั้นตอน decode จะอ่านข้อมูลเหล่านี้ควบคู่ไปกับส่วนอื่นๆ ดังนั้นหากไม่มีการทำ prefix caching ตัว system prompt ขนาด 3,000 token จะเพิ่ม TTFT ในทุกๆ คำขอ ในขณะที่ความเร็ว token ต่อวินาทีแทบจะไม่เปลี่ยนแปลง
เกือบจะไม่เปลี่ยนแปลง แต่ไม่เชิงเสียทีเดียว เพราะ KV entries ส่วนเกินเหล่านั้นจะถูกอ่านซ้ำในทุกขั้นตอนของ decode ดังนั้น prompt ที่ยาวมากจึงทำให้การ decode ช้าลงเล็กน้อย ซึ่งส่วนถัดไปจะอธิบายเรื่องนี้
วิธีแก้ไขคือการหยุดคำนวณ prefix เดิมซ้ำ เซิร์ฟเวอร์ที่มี prefix caching จะเก็บ KV cache ของ prefix ที่ใช้ร่วมกันไว้และนำกลับมาใช้ใหม่ ดังนั้นคำขอที่สองที่มี system prompt เดียวกันจะข้ามส่วน prefill นั้นไปโดยสิ้นเชิง vLLM เรียกสิ่งนี้ว่า automatic prefix caching ให้ตรวจสอบ vllm serve --help ในเวอร์ชันที่คุณใช้งาน เนื่องจากค่าเริ่มต้นมีการเปลี่ยนแปลงในแต่ละ release ตัว KV cache ที่อยู่ใน GPU นั้นเป็นคนละอย่างกับ prompt cache ที่ผู้ให้บริการ API เรียกเก็บเงินจากคุณ และ ความแตกต่างระหว่าง KV cache และ prompt cache เป็นหัวข้อที่ควรศึกษาให้เข้าใจก่อนที่คุณจะปรับแต่งค่าใดค่าหนึ่ง
เหตุใดกระบวนการ decode จึงช้าลงเมื่อ context เต็ม?
มีสองสาเหตุหลัก ซึ่งทั้งสองประเด็นเกี่ยวข้องกับ KV cache
สาเหตุแรกคือแบนด์วิดท์ ในทุกขั้นตอนของการ decode กลไก attention จะต้องอ่าน key และ value ของทุก token ก่อนหน้า ในขณะที่น้ำหนัก (weights) ของโมเดลเป็นต้นทุนคงที่ต่อหนึ่ง token แต่ KV cache จะมีขนาดเพิ่มขึ้นเรื่อยๆ คุณสามารถคำนวณขนาดของมันได้จาก config.json ของโมเดล โดยจำนวนไบต์ต่อ token จะเท่ากับ 2 คูณด้วย num_hidden_layers, คูณด้วย num_key_value_heads, คูณด้วยขนาดของ head (head dimension) และคูณด้วยจำนวนไบต์ต่อ element ให้ใช้ค่าจาก head_dim เมื่อระบุไว้ใน config และใช้ค่า hidden_size หารด้วย num_attention_heads เฉพาะในกรณีที่ไม่มีระบุไว้ เนื่องจากโมเดลบางรุ่นกำหนดค่าทั้งสองอย่างนี้แยกจากกัน ตัวอย่างเช่น Mistral NeMo มีความกว้าง 5,120 และมี 32 heads แต่มีขนาด head dimension อยู่ที่ 128 ไม่ใช่ 160 ส่วนเลข 2 ตัวหน้าคือการนับรวมทั้ง key และ value
สำหรับโครงสร้างโมเดลขนาด 8 พันล้านพารามิเตอร์ทั่วไปที่มี 32 layers, 8 key และ value heads ภายใต้กลไก GQA (grouped query attention), ขนาด head dimension 128, ที่ความละเอียด 16 bit จะได้ผลลัพธ์เป็น 2 x 32 x 8 x 128 x 2 = 131,072 ไบต์ หรือประมาณ 128 KiB ต่อ token ดังนั้นบทสนทนาที่มีความยาว 8,000 token จะใช้ KV cache ประมาณ 1 GB ต่อหนึ่งคำขอ
สาเหตุที่สองคือความจุ หน่วยความจำ 1 GB นั้นไม่สามารถนำไปใช้เก็บน้ำหนักหรือ context ของผู้ใช้รายอื่นได้ เซิร์ฟเวอร์จะกำหนดขนาดของ KV pool ไว้ตั้งแต่ตอนเริ่มต้นระบบ โดยใน vLLM จะกำหนดผ่าน --gpu-memory-utilization และเมื่อ pool เต็ม คำขอใหม่จะต้องรอคิว การที่ vllm:num_requests_waiting เพิ่มสูงขึ้นในขณะที่ vllm:kv_cache_usage_perc ยังคงอยู่ที่ระดับใกล้ 1 คือสัญญาณบ่งชี้ที่ชัดเจนของสถานะดังกล่าว สแต็กซอฟต์แวร์บางตัวอาจเลือกที่จะขัดจังหวะคำขอที่กำลังประมวลผลอยู่แล้วนำไปคำนวณ cache ใหม่ในภายหลังแทนการเข้าคิว ซึ่งผู้ใช้จะรู้สึกว่าการตอบสนองหยุดชะงักไปกลางคัน
context ที่ยาวจะทำให้คุณเสียต้นทุนสองต่อ คือต้องใช้เวลา prefill มากขึ้นในช่วงเริ่มต้น และต้องใช้การอ่านหน่วยความจำต่อ token มากขึ้นตลอดระยะเวลาที่เหลือของการตอบกลับ
เหตุใดการทำ batching จึงช่วยเพิ่ม throughput แต่ส่งผลเสียต่อ tail latency
เนื่องจากขั้นตอน decode ถูกจำกัดด้วย bandwidth การประมวลผลคำขอเพิ่มเติมจึงแทบไม่มีต้นทุนเพิ่มในฝั่ง compute การอ่าน weight หนึ่งครั้งสามารถสร้าง token ให้กับทุก sequence ใน batch ได้ ดังนั้น throughput รวมจึงเพิ่มขึ้นเกือบเป็นเส้นตรงตามขนาดของ batch จนกว่า KV pool จะเต็มหรือ batch มีขนาดใหญ่จนกลับไปถูกจำกัดด้วย compute อีกครั้ง การทำ continuous batching จะสร้าง batch ใหม่ในทุกขั้นตอน ดังนั้นคำขอที่เสร็จสิ้นจะออกไปและคำขอที่รออยู่ในคิวจะเข้ามาแทนที่โดยไม่ต้องรอคำขออื่นในกลุ่ม
ผลกระทบจะปรากฏให้เห็นในค่า percentiles โดย token ถัดไปของผู้ใช้แต่ละคนจะต้องรอส่วนที่ช้าที่สุดของขั้นตอนที่ใช้ร่วมกัน ส่งผลให้ค่า p50 หรือค่ามัธยฐานยังคงอยู่ในระดับที่ยอมรับได้ ในขณะที่ค่า p99 ซึ่งเป็นคำขอที่ช้าที่สุด 1 รายการใน 100 รายการจะยืดออกไป ค่า p99 คือสิ่งที่ผู้ใช้สังเกตเห็นได้ชัดเจนที่สุด เพราะมันคือจังหวะหยุดชะงักระหว่างประโยค
ขั้นตอน prefill ทำให้ปัญหานี้ชัดเจนยิ่งขึ้น คำสั่ง (prompt) ขนาดใหญ่ที่เข้ามาในระหว่างการ streaming จะครอบครองอุปกรณ์เป็นขั้นตอนที่ยาวนาน ทำให้ทุกคนที่กำลัง streaming อยู่เห็นช่องว่างของเวลา การทำ chunked prefill ช่วยลดปัญหานี้ได้เกือบทั้งหมดโดยการตัด prompt ที่ยาวออกเป็นส่วนๆ แล้วนำแต่ละส่วนไปผสมใน batch ของการ decode ตั้งแต่เดือนตุลาคม 2026 เป็นต้นมา vLLM V1 engine ได้ตั้งค่านี้เป็นค่าเริ่มต้นและเปิดให้ปรับสมดุลผ่าน --max-num-batched-tokens เอกสารการปรับแต่งของ vLLM ระบุถึงการแลกเปลี่ยนนี้ไว้อย่างชัดเจนว่า ค่าที่น้อยลงประมาณ 2048 จะให้ inter token latency (ITL) ที่ดีกว่าเนื่องจากมีการขัดจังหวะการ decode ด้วย prefill น้อยลง และค่าที่มากขึ้นจะให้ TTFT ที่ดีกว่าเนื่องจากสามารถใส่ token ของ prefill ลงใน batch เดียวได้มากขึ้น flag ดังกล่าวคือการเลือกระหว่าง prefill กับ decode ซึ่งแสดงออกมาเป็นตัวเลขที่คุณสามารถปรับได้ จุดที่ค่า p99 เริ่มไม่เป็นที่ยอมรับถือเป็นคำถามเรื่องขีดความสามารถของระบบ และ จำนวนผู้ใช้พร้อมกันที่ LLM แบบ self-hosted หนึ่งตัวสามารถรองรับได้ ได้อธิบายรายละเอียดเรื่องนี้โดยใช้ตัวชี้วัดเดียวกัน
เหตุใด GPU ที่ใหญ่ขึ้นบางครั้งจึงไม่ช่วยให้ประสิทธิภาพดีขึ้น
เนื่องจากขนาดที่ใหญ่ขึ้นมักหมายถึงพลังในการประมวลผลที่มากขึ้น แต่กระบวนการ decode ไม่ได้ต้องการพลังประมวลผลดังกล่าว
ลองเปรียบเทียบสองแถวจากตารางด้านบน A100 80GB มีแบนด์วิดท์ที่ระบุไว้ที่ 2039 GB/s ในขณะที่ L40S อยู่ที่ 864 GB/s ซึ่งขีดจำกัดของ decode ก็เป็นไปตามนั้นอย่างแม่นยำ คือ 127 tokens ต่อวินาที เทียบกับ 54 ส่วน RTX 4090 เป็นการ์ดที่เร็วมากในเกือบทุกด้าน และด้วยแบนด์วิดท์ 1008 GB/s ทำให้ขีดจำกัดของมันอยู่ที่ 63 ไม่ว่าการ์ดสองใบจะแตกต่างกันในด้านอื่นอย่างไร การ decode แบบ single stream จะแปรผันตรงกับค่าแบนด์วิดท์ที่ระบุไว้ในเอกสารข้อมูลทางเทคนิคเสมอ
ดังนั้น จึงมีสองวิธีในการทำให้ decode เร็วขึ้น ได้แก่ การอ่านจำนวนไบต์ต่อ token ให้น้อยลง (ทำ quantization ให้กับ weight หรือรันโมเดลที่เล็กลง) หรือการซื้อแบนด์วิดท์ที่มากขึ้น ส่วนกระบวนการ prefill นั้นตรงกันข้าม เพราะต้องการพลังประมวลผล ดังนั้นการ์ดที่เร็วกว่าจึงช่วยลดเวลา TTFT สำหรับ prompt ที่ยาวได้อย่างแท้จริง หากปัญหาคือการรอ token แรกนานถึงสี่วินาที ฮาร์ดแวร์ที่ดีขึ้นอาจช่วยแก้ปัญหานี้ได้ แต่หากปัญหาคือข้อความแสดงผลช้า ฮาร์ดแวร์ใหม่มักจะไม่ช่วยอะไร
ควรแยกการทำงานของ prefill และ decode ไว้คนละ worker หรือไม่?
กลุ่มซอฟต์แวร์สำหรับให้บริการขนาดใหญ่ใช้วิธีนี้โดยเฉพาะ ซึ่งเรียกว่าการแยกส่วน prefill และ decode (prefill and decode disaggregation) โดยจะมีกลุ่ม worker ชุดหนึ่งทำหน้าที่ prefill เพียงอย่างเดียว และอีกชุดทำหน้าที่ decode เพียงอย่างเดียว จากนั้น KV cache ที่สร้างขึ้นจากชุดแรกจะถูกส่งต่อไปยังชุดที่สองผ่านเครือข่ายความเร็วสูง วิธีนี้ได้ผลเพราะทั้งสองขั้นตอนต้องการฮาร์ดแวร์และการจัดตารางเวลาที่แตกต่างกัน โดย prefill ต้องการพลังการประมวลผลและ batch ขนาดใหญ่ ส่วน decode ต้องการแบนด์วิดท์และรองรับลำดับงานที่ทำงานพร้อมกันจำนวนมาก การแยกส่วนช่วยให้แต่ละกลุ่มขยายขนาดได้ด้วยตนเอง และป้องกันไม่ให้ prompt ขนาดใหญ่เพียงรายการเดียวทำให้ stream อื่นๆ ทั้งหมดต้องหยุดชะงัก
บน VPS (virtual private server) เครื่องเดียวที่มี GPU เพียงตัวเดียว แทบไม่มีความจำเป็นต้องทำเช่นนี้ เพราะจะเป็นการแบ่งทรัพยากรของอุปกรณ์ชิ้นเดียวให้แย่งกันเอง และจะเปลี่ยนการอ้างอิง pointer ให้กลายเป็นการโอนย้าย cache ขนาดหลาย gigabyte ผ่านเครือข่าย เทคนิคนี้จะคุ้มค่าก็ต่อเมื่อคุณมีตัวเร่งความเร็ว (accelerator) มากพอที่จะอุทิศเครื่องทั้งเครื่องให้กับแต่ละขั้นตอน และมีปริมาณ traffic ที่สม่ำเสมอมากพอที่จะทำให้ทั้งสองกลุ่มทำงานได้ตลอดเวลา หากต่ำกว่าระดับนั้น การใช้ chunked prefill จะให้ผลลัพธ์ด้านการแยกส่วนที่ใกล้เคียงกันมากกว่าด้วยการตั้งค่าเพียง flag เดียว
สิ่งที่ควรปรับเปลี่ยนเมื่อค่าตัวเลขไม่เป็นไปตามเป้าหมาย
เมื่อค่า TTFT สูงเกินไป:
- ลดความยาวของ prompt ลง ค่าใช้จ่ายของ prefill จะคิดตามจำนวน token ของ prompt และหากไม่ได้เปิดใช้งาน prefix caching ระบบจะต้องประมวลผล system prompt ใหม่ทุกครั้งที่มีการร้องขอ
- เปิดใช้งาน prefix caching เพื่อให้ส่วนนำของข้อความที่ซ้ำกันถูกคำนวณเพียงครั้งเดียวแทนที่จะคำนวณใหม่ทุกครั้ง
- เพิ่มค่า
--max-num-batched-tokensเพื่อให้งานในส่วน prefill ถูกประมวลผลในแต่ละขั้นตอนมากขึ้น - ตรวจสอบคิวงานก่อนที่จะสรุปว่าเป็นปัญหาที่ตัวโมเดล หากค่า
vllm:num_requests_waitingมากกว่าศูนย์ หมายความว่าคำขอยังไม่ได้เริ่มประมวลผล ซึ่งเป็นปัญหาด้านขีดความสามารถของระบบ
เมื่อค่า tokens per second ต่ำเกินไป:
- ทำการ quantize weights เนื่องจากจำนวนไบต์ต่อ weight ที่น้อยลงจะช่วยลดจำนวนไบต์ที่ต้องอ่านต่อการสร้างหนึ่ง token
- ตรวจสอบ memory bandwidth ของการ์ดจอเทียบกับตารางด้านบนเพื่อดูว่าประสิทธิภาพการทำงานใกล้ถึงขีดจำกัดสูงสุดแล้วหรือไม่
- ลดค่า
--max-num-batched-tokensเพื่อให้การทำ prefill ขัดจังหวะการทำ decode น้อยลง - ตรวจสอบความยาวของ context หากบทสนทนามีความยาวหลายพัน token ระบบจะต้องอ่าน KV cache ที่มีขนาดใหญ่ขึ้นในทุกขั้นตอน
Runtime ที่ใช้ก็มีผลเช่นกัน เนื่องจาก Ollama และ vLLM มีการจัดตารางเวลาสำหรับ prefill และ decode ที่แตกต่างกัน การตั้งค่าที่ช่วยเพิ่มประสิทธิภาพในตัวหนึ่งอาจไม่มีผลกับอีกตัวหนึ่ง ให้ทำการวัดผลก่อนเสมอทั้งในสองระยะ แล้วจึงค่อยปรับเปลี่ยนทีละอย่าง
FAQ
ทำไม token แรกถึงใช้เวลาหลายวินาที แต่หลังจากนั้นถึงแสดงผลได้รวดเร็ว?
ช่วงเวลารอคอยคือขั้นตอน prefill และการแสดงผลคือขั้นตอน decode ขั้นตอน prefill จะประมวลผล prompt ทั้งหมดในรอบการคำนวณเดียวเพื่อให้ได้ผลลัพธ์แรกออกมา ดังนั้นระยะเวลาจึงแปรผันตามความยาวของ prompt จากนั้นขั้นตอน decode จะสร้าง token ออกมาทีละหนึ่งตัวต่อรอบ โดยมีความเร็วที่ถูกกำหนดโดย memory bandwidth ซึ่งแทบไม่ขึ้นกับความยาวของ prompt เดิม สาเหตุที่พบบ่อยคือการใช้ system prompt ที่ยาวในทุกคำขอ การใช้ prefix caching จะช่วยลดภาระในส่วนที่ซ้ำซ้อนนี้ได้
prompt ที่ยาวขึ้นทำให้ความเร็วในการสร้าง token ต่อวินาทีลดลงหรือไม่?
ลดลงเล็กน้อยด้วยเหตุผลที่ต่างจาก TTFT ในทุกขั้นตอนการ decode ระบบต้องอ่านค่า keys และ values ของ token ก่อนหน้าทั้งหมด ดังนั้น KV cache ที่ใหญ่ขึ้นหมายถึงจำนวนไบต์ที่ต้องอ่านต่อ token มากขึ้น สำหรับโมเดลขนาด 8 พันล้านพารามิเตอร์ทั่วไป cache จะมีขนาดประมาณ 128 KiB ต่อ token ดังนั้น context ขนาด 8,000 token จึงเท่ากับข้อมูลประมาณ 1 GB ที่ต้องถูกประมวลผลในทุกขั้นตอน อย่างไรก็ตาม ผลกระทบหลักของ prompt ที่ยาวจะยังคงอยู่ที่ TTFT ไม่ใช่ความเร็วในการ streaming
ข้อมูลจำเพาะของ GPU ใดที่ใช้คาดการณ์ความเร็วในการ decode?
Memory bandwidth ให้นำค่า bandwidth ที่ระบุไว้หารด้วยขนาดของ weights ในหน่วยความจำ คุณจะได้ขีดจำกัดสูงสุดเชิงทฤษฎีสำหรับหนึ่ง stream การ์ดที่มีพลังประมวลผลสูงกว่าแต่มี bandwidth เท่ากันจะไม่สามารถ streaming ได้เร็วขึ้น นี่คือเหตุผลที่การทำ quantization weights ให้เหลือ 8 bits ช่วยเพิ่มขีดจำกัดการ decode ได้ประมาณสองเท่า เพราะช่วยลดจำนวนไบต์ของ weights ที่ต้องอ่านต่อ token ลงครึ่งหนึ่ง แต่ผลลัพธ์ที่วัดได้จริงมักจะน้อยกว่านั้น เนื่องจาก KV cache ยังคงต้องถูกอ่านตามขนาดเดิม และรูปแบบ 8 bit บางประเภทเพิ่มภาระงานต่อ token เช่น การทำ quantization ให้กับ activations
ทำไม throughput ถึงเพิ่มขึ้นเมื่อเพิ่มจำนวนผู้ใช้ แต่ผู้ใช้แต่ละคนกลับรู้สึกว่าช้าลง?
การอ่าน weights หนึ่งครั้งสามารถสร้าง token ให้กับทุก sequence ใน batch ได้ ดังนั้นจำนวน token รวมต่อวินาทีจึงเพิ่มขึ้นตามขนาดของ batch แต่เนื่องจาก token ของแต่ละคนต้องรอรอบการประมวลผลร่วมกัน ค่า latency ต่อผู้ใช้จึงเพิ่มขึ้นในเวลาเดียวกัน ให้สังเกตค่า p99 inter token latency แทนตัวเลข aggregate throughput และตรวจสอบ vllm:num_requests_waiting เพื่อดูว่าคำขอกำลังรอคิวอยู่แทนที่จะได้รับการประมวลผลหรือไม่