บทช่วยสอน Multi-Token Prediction: วิธีเร่งความเร็ว LLMs

Multi-Token Prediction คืออะไร?

ส่วนใหญ่แล้ว LLM จะสร้างข้อความทีละโทเคน โมเดลจะทำนายโทเคนถัดไป เพิ่มเข้าไปในบริบท แล้วทำซ้ำขั้นตอนเดิมอีกครั้ง วิธีนี้เชื่อถือได้ แต่ช้า เพราะทุกโทเคนใหม่มักต้องถอดรหัสอีกรอบ

Multi-Token Prediction เปลี่ยนสิ่งนี้ด้วยการให้โมเดลมองไปข้างหน้าและเสนอหลายโทเคนในอนาคตแทนที่จะมีเพียงโทเคนเดียว จากนั้นโทเคนที่เสนอจะถูกตรวจสอบโดยกระบวนการถอดรหัสหลัก หากทำนายถูก โมเดลจะยอมรับหลายโทเคนพร้อมกัน หากมีโทเคนผิด โมเดลจะย้อนกลับไปเส้นทางปกติตั้งแต่จุดนั้น

ในการใช้งานจริง MTP ทำงานเหมือนกลไกร่างในตัว โมเดลจะร่างโทเคนถัดไปที่เป็นไปได้ ตรวจสอบ แล้วเก็บโทเคนที่ผ่าน ยิ่งโทเคนร่างถูกยอมรับมากเท่าไร ก็ยิ่งต้องถอดรหัสเต็มรูปแบบน้อยลงเท่านั้น ซึ่งสามารถเพิ่มโทเคนต่อวินาทีได้โดยไม่กระทบคุณภาพผลลัพธ์สุดท้าย

พูดให้เข้าใจง่ายคือ:

• ไม่มี MTP: สร้างโทเคนที่ 1 → สร้างโทเคนที่ 2 → สร้างโทเคนที่ 3
• มี MTP: ร่างหลายโทเคน → ตรวจสอบ → ยอมรับโทเคนที่ถูกพร้อมกัน

นี่คือเหตุผลที่ MTP ทำให้การอนุมาน LLM แบบโลคัลรู้สึกเร็วขึ้นมาก แทนที่จะบังคับให้โมเดลเดินหน้าทีละก้าวเล็ก ๆ ก็ปล่อยให้กระโดดไปข้างหน้าได้อย่างปลอดภัยเมื่อการร่างถูกต้อง 

ในเครื่องมืออย่าง llama.cpp และการใช้งานแบบ vLLM-style สิ่งนี้เกี่ยวข้องอย่างใกล้ชิดกับการถอดรหัสแบบ speculative ซึ่งโทเคนร่างจะได้รับการยอมรับต่อเมื่อสอดคล้องกับผลของตัวตรวจสอบเท่านั้น 

1. ตั้งค่าเครื่อง RunPod RTX 3090

สำหรับคู่มือนี้ ฉันใช้อินสแตนซ์ GPU ของ RunPod ที่เป็น RTX 3090 จะใช้ GPU ตัวอื่นที่รองรับ CUDA ก็ได้ แต่ผล benchmark ในบทความนี้อ้างอิงจากการตั้งค่า RTX 3090

ขั้นแรก สร้าง RunPod pod ใหม่และเลือก GPU RTX 3090

ก่อนดีพลอย pod ให้แก้ไขการตั้งค่าเทมเพลต:

• เพิ่มขนาดดิสก์ของโวลุ่มเป็น 100 GB

• เพิ่มพอร์ต HTTP เพิ่มเติม: 8910

• เพิ่มตัวแปรสภาพแวดล้อมชื่อ HF_TOKEN และตั้งค่าเป็นโทเคนเข้าถึง Hugging Face ของคุณ 

พอร์ต HTTP เพิ่มเติมช่วยให้เข้าถึงเซิร์ฟเวอร์และเว็บ UI ของ llama.cpp ได้จากเบราว์เซอร์ โทเคนของ Hugging Face ช่วยยืนยันตัวตนคำขอดาวน์โหลดและอาจเพิ่มความเร็วการดาวน์โหลดโมเดล โดยเฉพาะไฟล์ GGUF ขนาดใหญ่

อัปเดตเทมเพลตแล้วให้ดีพลอย pod เมื่อทำงานแล้ว ให้รอจน RunPod ให้เข้าถึงอินสแตนซ์ JupyterLab เปิด JupyterLab แล้วเปิดเทอร์มินัลใหม่

ในเทอร์มินัล ให้ติดตั้งแพ็กเกจระบบที่จำเป็น:

apt update
apt install -y git cmake build-essential curl wget python3-pip

2. โคลนและสลับไปยังสาขา MTP

ต่อไป ไปที่ไดเรกทอรี workspace ซึ่งเราจะติดตั้งและบิลด์ llama.cpp:

cd /workspace

โคลนที่เก็บ llama.cpp:

git clone --depth 1 https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

การเปลี่ยนแปลงของ MTP ยังอยู่ระหว่างการทดสอบผ่าน pull request เฉพาะของ llama.cpp ดังนั้นเราจะดึงและสลับไปยังสาขานั้น เพื่อใช้การติดตั้ง MTP ล่าสุดก่อนที่จะถูกรวมเข้า main build มาตรฐาน

ดึงสาขา MTP มาไว้ในเครื่อง:

git fetch origin pull/22673/head:mtp-pr
git checkout mtp-pr

คำสั่งนี้จะสลับบิลด์ llama.cpp ในเครื่องของคุณไปเป็นเวอร์ชันที่เปิดใช้ MTP ซึ่งเราจะใช้ต่อในคู่มือนี้

3. บิลด์ llama.cpp พร้อมรองรับ CUDA

เมื่ออยู่บนสาขาที่เปิดใช้ MTP แล้ว ให้บิลด์ llama.cpp พร้อมรองรับ CUDA เพื่อให้โมเดลใช้ GPU RTX 3090 แทนการอนุมานบน CPU

รันการตั้งค่า CMake build:

cmake -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release

จากนั้นคอมไพล์สองทาร์เก็ตที่เราต้องใช้ในคู่มือนี้:

cmake --build build --target llama-cli llama-server -j

คำสั่งนี้จะบิลด์:

• llama-cli สำหรับทดสอบแบบ command-line อย่างรวดเร็ว

• llama-server สำหรับเปิดเซิร์ฟเวอร์ที่เข้ากันได้กับ OpenAI และเข้าถึงผ่านเบราว์เซอร์

เมื่อบิลด์เสร็จ ให้คัดลอกไฟล์ไบนารี llama-server ไปไว้ที่ไดเรกทอรีหลักของ llama.cpp:

cp ./build/bin/llama-server ./llama-server

เพื่อให้รันเซิร์ฟเวอร์จากรูทของโปรเจกต์ได้สะดวกในขั้นตอนถัดไป

4. ดาวน์โหลดโมเดล Qwen3.6-27B-MTP

ถัดไป ดาวน์โหลดโมเดล Qwen3.6 27B MTP แบบ GGUF เพื่อใช้ทดสอบ เราจะรันโมเดลนี้ก่อนโดยไม่เปิด MTP แล้วค่อยเปิด MTP เพื่อเปรียบเทียบความเร็ว

ก่อนอื่น ติดตั้งเครื่องมือดาวน์โหลดของ Hugging Face:

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

จากนั้นเปิดใช้โหมดดาวน์โหลดของ Hugging Face ให้เร็วขึ้น:

export HF_HUB_ENABLE_HF_TRANSFER=1

ช่วยเร่งการดาวน์โหลดโมเดลขนาดใหญ่ โดยเฉพาะไฟล์ GGUF

ตอนนี้ให้สร้างไดเรกทอรีเฉพาะสำหรับโมเดล:

mkdir -p /workspace/models/qwen3.6-mtp

ดาวน์โหลดโมเดล Qwen3.6 27B MTP แบบ GGUF:

hf download froggeric/Qwen3.6-27B-MTP-GGUF \
 Qwen3.6-27B-Q4_K_M-mtp.gguf \
 --local-dir /workspace/models/qwen3.6-mtp

ถ้าสนใจการปรับจูน LLM ลองดูบทความสอนของฉันเกี่ยวกับ การปรับจูน Qwen3.6 บนชุดข้อมูลถาม-ตอบด้านการแพทย์

5. รัน Qwen3.6-27B โดยไม่เปิดใช้ MTP

มาถึงส่วนหลักของคู่มือ: ทดสอบความเร็วโมเดลก่อนและหลังเปิดใช้ MTP

เริ่มจากรันโมเดลโดยไม่เปิด MTP เพื่อเป็นค่าพื้นฐานสำหรับเปรียบเทียบภายหลัง เราใช้โมเดล เดียวกัน GPU เดียวกัน ขนาดคอนเท็กซ์เดียวกัน และการตั้งค่าเซิร์ฟเวอร์เดียวกัน สิ่งที่จะเปลี่ยนหลัก ๆ ในขั้นถัดไปคือการเปิด MTP

กลับไปที่ไดเรกทอรี llama.cpp:

cd /workspace/llama.cpp

สตาร์ทเซิร์ฟเวอร์โดยไม่เปิด MTP:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-no-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

คำสั่งนี้จะเริ่มเซิร์ฟเวอร์ llama.cpp ที่เข้ากันได้กับ OpenAI บนพอร์ต 8910.

ตัวโมเดลอาจใช้เวลาโหลดสักครู่ เพราะเซิร์ฟเวอร์ต้องโหลดน้ำหนักโมเดลเข้าหน่วยความจำของ GPU เมื่อพร้อมแล้ว เทอร์มินัลจะแจ้งว่าเซิร์ฟเวอร์พร้อมใช้งานบนพอร์ต 8910.

เนื่องจากเราเปิดพอร์ตนี้ไว้ตอนตั้งค่าเทมเพลต RunPod จึงไม่ต้องตั้งค่าอย่างอื่นเพิ่มเติม กลับไปที่แดชบอร์ด RunPod แล้วคลิกลิงก์ที่เชื่อมกับพอร์ต 8910 จะเปิด เว็บ UI ของ llama.cpp ในเบราว์เซอร์ โดยโหลดโมเดลโลคัลไว้พร้อมแล้ว

จากตรงนั้น คุณสามารถเริ่มทดสอบพรอมป์ต์ได้โดยตรงในเบราว์เซอร์ คล้ายกับที่ใช้หน้าต่างสนทนา

ในการทดสอบพื้นฐานของฉัน โมเดลสร้างคำตอบได้ราวๆ 38.86 โทเคน/วินาที โดยไม่เปิด MTP แม้ใช้พรอมป์ต์ที่ซับซ้อนขึ้น ความเร็วก็คงอยู่ในช่วงใกล้เคียงกัน 

สำหรับโมเดล 27B ที่รันบน RTX 3090 นี่ถือว่าใช้งานได้ดีอยู่แล้ว โดยเฉพาะเมื่อเทียบกับการ์ดศูนย์ข้อมูลรุ่นใหม่ที่เร็วกว่าและมีหน่วยความจำมากกว่า 

6. รัน Qwen3.6-27B โดยเปิดใช้ MTP

ตอนนี้จะรันโมเดลเดิมอีกครั้ง แต่คราวนี้เปิดใช้ MTP

กลับไปยังเทอร์มินัลที่รันเซิร์ฟเวอร์อยู่และหยุดด้วย:

CTRL + C

จุดสำคัญคือเรา ไม่ได้เปลี่ยนโมเดล GPU ควอนไทซ์ หรือการตั้งค่ารันไทม์ส่วนใหญ่ เราเพียงเพิ่มแฟล็กที่เกี่ยวกับ MTP สองตัว:

--spec-type mtp
--spec-draft-n-max 3

แฟล็กแรกบอกให้ llama.cpp ใช้การถอดรหัสแบบ speculative สไตล์ MTP แฟล็กที่สองกำหนดจำนวนโทเคนร่างสูงสุดเป็น 3 หมายความว่าโมเดลสามารถลองร่างโทเคนอนาคตได้สูงสุดสามโทเคนก่อนการตรวจสอบ

เริ่มเซิร์ฟเวอร์อีกครั้งโดยเปิดใช้ MTP:

./llama-server \
-m "/workspace/models/qwen3.6-mtp/Qwen3.6-27B-Q4_K_M-mtp.gguf" \
--alias qwen3.6-27b-mtp \
--host 0.0.0.0 \
--port 8910 \
-ngl 99 \
-c 100000 \
--spec-type mtp \
--spec-draft-n-max 3 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
-np 1 \
-b 2048 \
-ub 512 \
-t 8 \
-fa on \
--temp 0.7 \
--top-k 20 \
--top-p 0.95 \
--repeat-penalty 1.1 \
--metrics

เมื่อเซิร์ฟเวอร์พร้อม ให้รีเฟรชหน้าเบราว์เซอร์ หากไม่เชื่อมต่อใหม่อัตโนมัติ ให้ปิดแล้วเปิดลิงก์พอร์ต 8910 จากแดชบอร์ด RunPod อีกครั้ง 

ทดสอบโมเดลอีกครั้งด้วยพรอมป์ต์ประเภทเดิม

เมื่อเปิดใช้ MTP ความเร็วเพิ่มขึ้นอย่างเห็นได้ชัด สำหรับพรอมป์ต์ทักทายง่าย ๆ โมเดลทำได้ราว 65–67 โทเคน/วินาที เทียบกับค่าพื้นฐานราว 38.86 โทเคน/วินาที ถือว่าเพิ่มขึ้นมากจากการเพิ่มเพียงสองแฟล็กในบรรทัดคำสั่ง 

สำหรับพรอมป์ต์ที่ซับซ้อนขึ้น เช่นให้โมเดลสร้างเกมง่าย ๆ ด้วย Python ความเร็วจะลดลงเล็กน้อยแต่ยังเร็วกว่าแบบไม่ใช้ MTP มาก ในการทดสอบนั้น โมเดลสร้างได้ราว 56–61 โทเคน/วินาที ซึ่งยังถือว่าแรงสำหรับโมเดล 27B บน RTX 3090 

โดยรวมแล้ว การเปิด MTP ทำให้ Qwen3.6 27B เร็วขึ้นจากประมาณ 38 โทเคน/วินาที เป็น 65 โทเคน/วินาที บนเครื่อง RunPod RTX 3090 คิดเป็น ความเร็วเพิ่ม 1.71 เท่า หรือประมาณ ปริมาณงานสูงขึ้น 71% โดยไม่ต้องเปลี่ยนฮาร์ดแวร์หรือสลับเป็นโมเดลที่เล็กกว่า 

7. คำแนะนำ: เพิ่มความเร็วต่อด้วย TurboQuant

ผล benchmark ในคู่มือนี้ใช้การตั้งค่า MTP ดั้งเดิมของ llama.cpp โดยไม่เพิ่ม TurboQuant แพตช์แบบกำหนดเอง หรือการปรับแต่งรันไทม์อื่น ๆ เพื่อให้การทดสอบเรียบง่าย ทำซ้ำได้ และเน้นผลจากการเปิด MTP เพียงอย่างเดียว

หากต้องการดันประสิทธิภาพต่อไป ขั้นถัดไปที่ควรลองคือ ใช้ MTP ร่วมกับ TurboQuant โดย MTP เพิ่มปริมาณงานด้วยการยอมรับโทเคนที่ทำนายได้หลายตัว ส่วน TurboQuant ช่วยลดแรงกดดันของหน่วยความจำ KV-cache ระหว่างอนุมาน 

สิ่งนี้มีประโยชน์เป็นพิเศษกับโมเดลขนาดใหญ่ พรอมป์ต์บริบทยาว และ GPU อย่าง RTX 3090 ที่แบนด์วิธหน่วยความจำและ VRAM อาจเป็นข้อจำกัด

นี่จึงเป็นเหตุผลที่ผลลัพธ์ในชุมชน r/LocalLLaMA บางส่วนรายงานโทเคน/วินาทีสูงกว่าคู่มือนี้ การตั้งค่าเหล่านั้นมักผสาน MTP กับ TurboQuant บิลด์ที่แพตช์แล้ว การตั้งค่า KV-cache ที่ต่างออกไป หรือใช้ GPU ที่เร็วกว่า เนื่องจากบทความนี้โฟกัสการทดสอบแบบ MTP เพียว ๆ จึงควรมอง TurboQuant เป็นการทดลองถัดไปที่แนะนำ มากกว่าจะเป็นส่วนหนึ่งของชุดปัจจุบัน

บทส่งท้าย 

ระยะหลังฉันติดตามโพสต์ในชุมชน LocalLLaMA บน Reddit และน่าทึ่งมากที่การอนุมาน LLM แบบโลคัลพัฒนาไปไกล คนเริ่มรันโมเดลอย่าง Qwen3.6 27B เป็นเอเย่นต์ช่วยเขียนโค้ดแบบโลคัล แม้บน GPU รุ่นเก่าที่ VRAM จำกัด บางคนก็รันบน Mac และผลลัพธ์ก็ดีจริง ๆ

หลังจากทดสอบ MTP ด้วยตัวเอง ก็เข้าใจว่าทำไมถึงตื่นเต้นกันมาก ด้วยโมเดลเดิมและการตั้งค่า RTX 3090 เดิม การเปิด Multi-Token Prediction ทำให้ความเร็วการสร้างเพิ่มจากราว 38 โทเคน/วินาที เป็น 65 โทเคน/วินาที เกือบจะ เร็วขึ้น 2 เท่า โดยไม่ต้องอัปเกรด GPU หรือสลับเป็นโมเดลเล็กกว่า

คู่มือนี้โฟกัสการตั้งค่า MTP แบบเรียบง่ายและทำซ้ำได้ด้วย llama.cpp แต่นี่เหมือนเป็นเพียงจุดเริ่ม ขั้นต่อไปคือทดลองควอนไทซ์ GGUF ที่ดีกว่า MTP TurboQuant และการตั้งค่ารันไทม์ที่จูนมากขึ้น เพื่อดูว่าเราจะดันความเร็วอนุมานแบบโลคัลได้ไกลอีกแค่ไหน

สำหรับฉัน สิ่งที่น่าตื่นเต้นที่สุดคือความหมายต่อเอเย่นต์ช่วยเขียนโค้ดแบบโลคัล คุณสามารถรันโมเดลทรงพลังบนฮาร์ดแวร์ของตัวเอง ลดต้นทุนต่อคำขอ เก็บโค้ดเป็นส่วนตัว และใช้ผู้ช่วยเขียนโค้ด AI โดยไม่ต้องพึ่งพา API บนอินเทอร์เน็ตทั้งหมด LLM แบบโลคัลกำลังเร็วขึ้น ใช้งานได้จริงมากขึ้น และมีประโยชน์กว่าที่เคยในเวลาไม่นานนี้เอง