Hướng dẫn Multi-Token Prediction: Cách tăng tốc LLM

Multi-Token Prediction là gì?

Hầu hết LLM tạo văn bản từng token một. Mô hình dự đoán token kế tiếp, thêm vào ngữ cảnh, rồi lặp lại quy trình. Cách này đáng tin cậy nhưng có thể chậm vì mỗi token mới thường cần một bước giải mã nữa.

Multi-Token Prediction thay đổi điều này bằng cách cho phép mô hình nhìn trước và đề xuất nhiều token tương lai thay vì chỉ một. Những token dự thảo này sau đó được quy trình giải mã chính kiểm tra. Nếu dự đoán đúng, mô hình có thể chấp nhận nhiều token trong một lần. Nếu một token sai, mô hình quay về lộ trình bình thường từ điểm đó.

Trên thực tế, MTP hoạt động như một cơ chế phác thảo tích hợp. Mô hình phác thảo vài token khả dĩ tiếp theo, xác minh chúng và giữ lại những token hợp lệ. Càng nhiều token dự thảo được chấp nhận, càng cần ít bước giải mã đầy đủ hơn, từ đó tăng token mỗi giây mà không làm thay đổi chất lượng đầu ra cuối.

Nói đơn giản:

\n
• Không có MTP: Tạo token 1 → tạo token 2 → tạo token 3
\n
• Có MTP: Phác thảo nhiều token → xác minh → chấp nhận các token hợp lệ cùng lúc
\n

Đó là lý do MTP có thể khiến việc suy luận LLM cục bộ trở nên nhanh hơn nhiều. Thay vì buộc mô hình tiến từng bước nhỏ, nó cho phép mô hình nhảy có kiểm soát khi các dự đoán phác thảo là chính xác. 

Trong các công cụ như llama.cpp và các triển khai kiểu vLLM-style, điều này liên quan chặt chẽ tới speculative decoding, nơi các token dự thảo chỉ được chấp nhận khi khớp với đầu ra của bộ xác minh. 

1. Thiết lập máy RunPod RTX 3090

Trong hướng dẫn này, tôi dùng một phiên bản GPU RunPod với RTX 3090. Bạn có thể dùng GPU khác hỗ trợ CUDA, nhưng kết quả benchmark trong bài dựa trên cấu hình RTX 3090.

Trước tiên, tạo một pod RunPod mới và chọn GPU RTX 3090.

Trước khi triển khai pod, hãy chỉnh cài đặt template:

\n
• \n

  Tăng dung lượng đĩa volume lên 100 GB

  \n
\n
• \n

  Thêm một cổng HTTP bổ sung: 8910

  \n
\n
• \n

  Thêm biến môi trường tên HF_TOKEN và đặt giá trị là token truy cập Hugging Face của bạn. 

  \n
\n

Cổng HTTP bổ sung sẽ cho phép bạn truy cập máy chủ và giao diện web llama.cpp từ trình duyệt. Token Hugging Face giúp xác thực yêu cầu tải xuống và có thể cải thiện tốc độ tải mô hình, đặc biệt với các tệp GGUF lớn.

Sau khi cập nhật template, triển khai pod. Khi pod chạy, đợi RunPod cấp quyền truy cập vào phiên bản JupyterLab. Mở JupyterLab, rồi khởi chạy một terminal mới.

Trong terminal, cài các gói hệ thống cần thiết:

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

2. Clone và chuyển sang nhánh MTP

Tiếp theo, chuyển vào thư mục workspace nơi chúng ta sẽ cài đặt và build llama.cpp:

cd /workspace

Clone repository llama.cpp:

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

Các thay đổi MTP vẫn đang được thử nghiệm qua một pull request riêng trên llama.cpp, nên ta fetch và chuyển sang nhánh đó để dùng bản triển khai MTP mới nhất trước khi nó được nhập vào bản main tiêu chuẩn.

Fetch nhánh MTP về máy:

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

Thao tác này chuyển bản build llama.cpp cục bộ của bạn sang phiên bản đã bật MTP, và chúng ta sẽ dùng nó cho phần còn lại của hướng dẫn.

3. Build llama.cpp với hỗ trợ CUDA

Giờ bạn đang ở nhánh đã bật MTP, hãy build llama.cpp với hỗ trợ CUDA. Điều này cho phép mô hình dùng GPU RTX 3090 thay vì suy luận trên CPU.

Chạy cấu hình build CMake:

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

Sau đó biên dịch hai target chúng ta cần cho hướng dẫn này:

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

Cụ thể build:

\n
• \n

  llama-cli để chạy các thử nghiệm nhanh trên dòng lệnh

  \n
\n
• \n

  llama-server để khởi chạy máy chủ tương thích OpenAI có thể truy cập từ trình duyệt

  \n
\n

Khi build xong, sao chép binary llama-server vào thư mục chính của llama.cpp:

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

Làm vậy để dễ chạy máy chủ từ thư mục gốc dự án trong các bước sau.

4. Tải mô hình Qwen3.6-27B-MTP

Tiếp theo, tải mô hình Qwen3.6 27B MTP GGUF mà chúng ta sẽ dùng để kiểm thử. Ta sẽ chạy mô hình này trước khi bật MTP, rồi bật MTP để so sánh chênh lệch tốc độ.

Trước tiên, cài công cụ tải của Hugging Face:

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

Sau đó bật tải xuống Hugging Face nhanh hơn:

export HF_HUB_ENABLE_HF_TRANSFER=1

Điều này giúp tăng tốc tải các mô hình lớn, đặc biệt khi làm việc với tệp GGUF.

Giờ tạo thư mục riêng cho mô hình:

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

Tải mô hình Qwen3.6 27B MTP GGUF:

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

Nếu bạn quan tâm đến fine-tuning LLM, hãy xem hướng dẫn của tôi về tinh chỉnh Qwen3.6 trên bộ dữ liệu Hỏi & Đáp y khoa.

5. Chạy Qwen3.6-27B khi chưa bật MTP

Giờ chúng ta đến phần chính của hướng dẫn: kiểm thử tốc độ mô hình trước và sau khi bật MTP.

Đầu tiên, ta sẽ chạy mô hình khi chưa bật MTP. Điều này cho ta một mốc nền sạch để so sánh sau. Ta dùng cùng mô hình, cùng GPU, cùng kích thước ngữ cảnh và cùng cài đặt máy chủ. Khác biệt lớn duy nhất ở bước tiếp theo là bật MTP.

Quay lại thư mục llama.cpp:

cd /workspace/llama.cpp

Khởi động máy chủ khi chưa bật MTP:

./llama-server \\n-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

Lệnh này khởi tạo một máy chủ llama.cpp tương thích OpenAI trên cổng 8910.

Mô hình có thể mất chút thời gian để tải vì máy chủ cần nạp trọng số vào bộ nhớ GPU. Khi sẵn sàng, terminal sẽ hiển thị máy chủ khả dụng trên cổng 8910.

Vì chúng ta đã mở cổng này khi thiết lập template RunPod, bạn không cần cấu hình gì thêm. Quay lại bảng điều khiển RunPod và nhấp liên kết tương ứng với cổng 8910. Thao tác này sẽ mở giao diện web llama.cpp trên trình duyệt của bạn, với mô hình cục bộ đã được nạp.

Từ đây, bạn có thể bắt đầu thử prompt trực tiếp trên trình duyệt, tương tự như dùng giao diện chat.

Trong bài kiểm thử nền của tôi, mô hình tạo phản hồi vào khoảng 38,86 token/giây khi chưa bật MTP. Ngay cả với prompt phức tạp hơn, tốc độ vẫn xoay quanh mức này. 

Với một mô hình 27B chạy trên RTX 3090, đây đã là kết quả có thể sử dụng, nhất là khi GPU này chậm hơn và bộ nhớ hạn chế so với các card trung tâm dữ liệu mới hơn. 

6. Chạy Qwen3.6-27B khi bật MTP

Giờ chúng ta sẽ chạy lại cùng mô hình, nhưng lần này bật MTP.

Quay lại terminal nơi máy chủ đang chạy và dừng lại bằng:

CTRL + C

Điểm quan trọng là chúng ta không thay đổi mô hình, GPU, lượng hoá, hay đa số cài đặt runtime. Chúng ta chỉ thêm hai cờ liên quan đến MTP:

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

Cờ đầu tiên báo cho llama.cpp dùng speculative decoding kiểu MTP. Cờ thứ hai đặt số lượng tối đa token dự thảo là 3. Nghĩa là mô hình có thể thử phác thảo tối đa ba token tương lai trước khi xác minh.

Bây giờ khởi động lại máy chủ với MTP được bật:

./llama-server \\n-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

Khi máy chủ sẵn sàng, làm mới trang trình duyệt. Nếu trang không tự kết nối lại, hãy đóng và mở lại liên kết cổng 8910 từ bảng điều khiển RunPod. 

Giờ hãy kiểm thử lại mô hình bằng cùng kiểu prompt.

Khi bật MTP, tốc độ tăng rõ rệt. Với một prompt chào hỏi đơn giản, mô hình đạt khoảng 65–67 token/giây. So với tốc độ nền khoảng 38,86 token/giây, đây là một cải thiện lớn chỉ với hai cờ dòng lệnh. 

Với prompt phức tạp hơn, như yêu cầu mô hình xây dựng một trò chơi đơn giản bằng Python, tốc độ thấp hơn đôi chút nhưng vẫn nhanh hơn nhiều so với nền không MTP. Trong bài đó, mô hình tạo ở khoảng 56–61 token/giây, vẫn là kết quả mạnh mẽ cho mô hình 27B trên RTX 3090. 

Tổng thể, bật MTP đã cải thiện Qwen3.6 27B từ khoảng 38 token/giây lên 65 token/giây trên cấu hình RunPod RTX 3090. Tức là nhanh hơn 1,71 lần, tương đương tăng 71% thông lượng, mà không đổi phần cứng hay chuyển sang mô hình nhỏ hơn. 

7. Khuyến nghị: Tối ưu tốc độ sâu hơn với TurboQuant

Bài benchmark trong hướng dẫn này dùng thiết lập MTP gốc của llama.cpp, không thêm TurboQuant, bản vá tuỳ chỉnh hay các tối ưu ở tầng runtime khác. Cách này giúp thử nghiệm đơn giản, có thể lặp lại, và tập trung vào mức tăng tốc chỉ từ việc bật MTP.

Để đẩy hiệu năng xa hơn, tối ưu tiếp theo nên khám phá là kết hợp MTP và TurboQuant. MTP cải thiện thông lượng bằng cách cho phép mô hình chấp nhận nhiều token dự đoán, trong khi TurboQuant giúp giảm áp lực bộ nhớ KV-cache trong quá trình suy luận. 

Điều này đặc biệt hữu ích cho mô hình lớn, prompt dài và các GPU như RTX 3090, nơi băng thông bộ nhớ và VRAM có thể trở thành điểm nghẽn.

Đó là lý do một số kết quả từ cộng đồng r/LocalLLaMA báo cáo tốc độ token/giây cao hơn hướng dẫn này. Các thiết lập đó thường kết hợp MTP với TurboQuant, build đã vá, cài đặt KV-cache khác, hoặc GPU nhanh hơn. Vì bài này tập trung vào benchmark sạch chỉ với MTP, TurboQuant nên được coi là thử nghiệm khuyến nghị tiếp theo chứ không phải một phần của thiết lập hiện tại.

Tổng kết 

Gần đây, tôi theo dõi các bài đăng trong cộng đồng LocalLLaMA trên Reddit và thật ấn tượng khi thấy suy luận LLM cục bộ đã tiến xa thế nào. Mọi người đang chạy các mô hình như Qwen3.6 27B làm tác nhân lập trình cục bộ, ngay cả trên các GPU đời cũ với VRAM hạn chế. Một số cũng chạy thiết lập tương tự trên máy Mac và kết quả thực sự ấn tượng.

Sau khi tự kiểm thử MTP, tôi hiểu vì sao lại có nhiều hào hứng đến vậy. Với cùng mô hình và cùng cấu hình RTX 3090, bật Multi-Token Prediction đã tăng tốc độ sinh từ khoảng 38 token/giây lên 65 token/giây. Gần như tăng gấp đôi mà không cần nâng cấp GPU hay chuyển sang mô hình nhỏ hơn.

Hướng dẫn này tập trung vào thiết lập MTP đơn giản và có thể lặp lại bằng llama.cpp, nhưng đây mới chỉ là khởi đầu. Bước tiếp theo là thử nghiệm lượng hoá GGUF tốt hơn, MTP, TurboQuant và các cài đặt runtime tinh chỉnh hơn để xem tốc độ suy luận cục bộ có thể đẩy xa đến đâu.

Điều khiến tôi hào hứng nhất là ý nghĩa đối với các tác nhân lập trình cục bộ. Bạn có thể chạy mô hình mạnh trên phần cứng của mình, giảm chi phí mỗi truy vấn, giữ mã nguồn riêng tư và dùng trợ lý lập trình AI mà không phụ thuộc hoàn toàn vào API qua internet. LLM cục bộ đang trở nên nhanh hơn, thực tế hơn và hữu ích hơn rất nhiều so với trước đây.