- Mô hình lớn sinh từng token một, mỗi token một lượt chạy, và lượt chạy bị giới hạn bởi băng thông bộ nhớ hơn là phép tính. Chấm vài token cùng lúc tốn gần bằng chấm một token.
- Mô hình nháp đoán trước γ token; mô hình lớn chấm cả γ token trong một lượt, nhận các token đầu đúng ý và sửa token đầu tiên bị từ chối.
- Phép nhận với xác suất min(1, p/q) và lấy lại từ phần dư (p − q)+ giữ đúng phân phối của mô hình lớn: chất lượng không đổi.
- Tăng tốc phụ thuộc tỉ lệ nhận α và độ rẻ của mô hình nháp. Bài báo đo được 2-3 lần trên T5-XXL; LM Studio và llama.cpp đều có sẵn tính năng này.
Code trong bài là Python 3 với numpy. Bài giả định bạn biết mô hình ngôn ngữ chọn token tiếp theo bằng cách lấy mẫu từ một phân phối xác suất; phần nhiệt độ lấy mẫu có trong bài temperature là gì. Số liệu lấy từ bản PDF của hai bài báo và tài liệu LM Studio, llama.cpp, đọc ngày 12/11/2026.
Vì sao sinh từng token lại chậm
Leviathan và cộng sự mở đầu bài báo bằng một nhận xét: sinh K token cần K lượt chạy nối tiếp của mô hình, vì token sau phụ thuộc token trước. Mỗi lượt phải đọc toàn bộ trọng số và KV cache từ bộ nhớ, nên bị giới hạn bởi băng thông bộ nhớ và việc truyền dữ liệu nhiều hơn số phép tính. Phần tính toán dư ra có thể dùng cho việc khác.
Chen và cộng sự ở DeepMind nói cùng ý theo cách khác: chấm điểm song song một đoạn ngắn vài token tốn thời gian gần bằng sinh một token từ mô hình lớn. Vậy nếu có ai đó đoán trước được vài token khá đúng, mô hình lớn có thể kiểm cả loạt trong một lượt. Người đoán là một mô hình nhỏ hơn nhiều, gọi là mô hình nháp (draft model); mô hình lớn gọi là mô hình đích (target model).
Đoán trước rồi duyệt một lượt
Mỗi vòng có ba bước. Mô hình nháp sinh γ token theo cách thường, từng token một, nhanh vì nó nhỏ. Mô hình lớn chạy một lượt trên đoạn đầu cộng γ token nháp, cho ra phân phối xác suất của nó ở cả γ + 1 vị trí. Rồi xét từ trái sang phải: nhận token nháp nếu hợp với mô hình lớn; gặp token đầu tiên bị từ chối thì thay bằng token do mô hình lớn lấy lại, bỏ các token nháp phía sau. Nếu nhận hết, mô hình lớn có sẵn phân phối ở vị trí tiếp theo nên sinh thêm một token nữa. Mỗi vòng vì thế cho từ 1 tới γ + 1 token.
Vì sao đầu ra không đổi
Gọi p là phân phối của mô hình lớn và q là phân phối của mô hình nháp ở cùng một vị trí. Token nháp x được nhận với xác suất \(\min\big(1, p(x)/q(x)\big)\): nếu mô hình lớn thích x ít nhất bằng mô hình nháp thì luôn nhận; nếu thích ít hơn thì nhận theo tỉ lệ. Khi từ chối, token mới được lấy từ phần dư:
\[p'(x) = \frac{\max\big(0,\ p(x) - q(x)\big)}{\sum_{y} \max\big(0,\ p(y) - q(y)\big)}\]
Đặt \(\beta = \sum_x \min\big(p(x), q(x)\big)\) là xác suất nhận. Mẫu số của p' bằng đúng \(1 - \beta\), nên xác suất ra token x là (mọi hàm lấy tại x):
\[\begin{aligned} P(x) &= \min(p, q) + (1 - \beta)\, p' \\ &= \min(p, q) + \max(0,\ p - q) \\ &= p \end{aligned}\]
Ví dụ với ba từ: mô hình lớn cho mèo 0,5; chó 0,3; cá 0,2, còn mô hình nháp cho 0,2; 0,6; 0,2. Nháp đề xuất mèo thì luôn nhận, vì 0,5 > 0,2. Nháp đề xuất chó thì chỉ nhận với xác suất 0,3 / 0,6 = 0,5. Xác suất nhận chung β = 0,2 + 0,3 + 0,2 = 0,7. Phần dư chỉ còn ở mèo (0,5 − 0,2 = 0,3), nên khi từ chối, token lấy lại luôn là mèo. Cộng lại: mèo 0,2 + 0,3 = 0,5; chó 0,6 × 0,5 = 0,3; cá 0,2. Đúng bằng p.
Khi lấy mẫu kiểu tham lam (nhiệt độ 0), quy tắc rút gọn thành: nhận token nháp nếu nó trùng token có xác suất cao nhất của mô hình lớn. Tài liệu LM Studio mô tả đúng như vậy: mô hình chính chỉ nhận token khớp với thứ nó tự sinh, và sau token nháp cuối được nhận luôn sinh thêm một token.
Nhanh hơn bao nhiêu
Gọi α là tỉ lệ nhận trung bình (kỳ vọng của β). Nếu coi các lần nhận độc lập, số token mỗi vòng có kỳ vọng \(\frac{1 - \alpha^{\gamma+1}}{1 - \alpha}\). Gọi c là tỉ lệ thời gian một lượt mô hình nháp so với một lượt mô hình lớn; định lý 3.8 của bài báo cho hệ số giảm thời gian:
\[\frac{1 - \alpha^{\gamma+1}}{(1 - \alpha)(\gamma c + 1)}\]
Hệ quả rút ra: chỉ tăng tốc được khi α > c, tức mô hình nháp phải vừa đoán đúng đủ thường vừa đủ rẻ. Bài báo thấy mô hình nháp nhỏ hơn khoảng hai bậc độ lớn thường cân bằng tốt nhất, với α từ 0,5 tới 0,9.
Bảng 2 của bài báo đo trên T5-XXL 11 tỉ tham số, chạy từng câu một trên một chip TPU-v4. Dịch Anh sang Đức với nháp T5-small 77 triệu tham số ở nhiệt độ 0: γ = 7, α = 0,75, nhanh 3,4 lần; ở nhiệt độ 1 nhanh 2,6 lần. Nháp T5-large đoán đúng hơn (α = 0,71 ở nhiệt độ 1) nhưng chỉ nhanh 1,4 lần, vì nó chậm. Chen và cộng sự dùng Chinchilla 70 tỉ tham số với một mô hình nháp 4 tỉ tham số tự huấn luyện, chạy 1,8 ms mỗi token so với 14,1 ms của Chinchilla. Với 4 token nháp mỗi vòng, tóm tắt XSum nhanh 1,92 lần, sinh code HumanEval nhanh 2,46 lần, còn điểm số gần như giữ nguyên: 0,112 so với 0,114 ROUGE-2 và 45,1% so với 47,0%.
Thử bằng numpy
Đoạn code dưới đây cài phép nhận, từ chối, tính phân phối đầu ra chính xác, lấy mẫu thật 200.000 lần, và tính số token kỳ vọng cùng hệ số tăng tốc.
"""Lấy mẫu suy đoán (speculative sampling) trên một từ vựng nhỏ, bằng numpy: phép nhận, từ chối của Leviathan và
cộng sự (2023) giữ đúng phân phối của mô hình lớn; công thức số token kỳ vọng mỗi lượt và hệ số tăng tốc."""
import numpy as np
def phan_phoi_dau_ra(p, q):
"""Phân phối CHÍNH XÁC của token ra sau một bước: mô hình nhỏ đề xuất x theo q, nhận với xác suất
min(1, p(x)/q(x)); bị từ chối thì lấy lại từ (p - q)+ đã chuẩn hóa. Trả về phân phối và xác suất nhận."""
p, q = np.asarray(p, float), np.asarray(q, float)
nhan = np.minimum(p, q) # q(x) * min(1, p(x)/q(x))
beta = nhan.sum()
du = np.maximum(p - q, 0.0)
if du.sum() > 0:
du = du / du.sum()
return nhan + (1 - beta) * du, beta
def lay_mau_mot_buoc(p, q, rng):
"""Lấy mẫu thật một bước theo đúng quy tắc trên. Trả về (token, có nhận token nháp không)."""
x = rng.choice(len(q), p=q)
if rng.random() < min(1.0, p[x] / q[x]):
return x, True
du = np.maximum(np.asarray(p) - q, 0.0)
return rng.choice(len(p), p=du / du.sum()), False
def so_token_ky_vong(alpha, gamma):
"""Số token sinh ra mỗi lượt chạy mô hình lớn khi đoán gamma token, mỗi token nhận với xác suất alpha."""
return (1 - alpha ** (gamma + 1)) / (1 - alpha)
def he_so_tang_toc(alpha, gamma, c):
"""Hệ số giảm thời gian chạy (định lý 3.8); c = thời gian một lượt mô hình nhỏ / một lượt mô hình lớn."""
return so_token_ky_vong(alpha, gamma) / (gamma * c + 1)
def mo_phong_mot_luot(alpha, gamma, rng):
"""Token nháp lần lượt được nhận với xác suất alpha; gặp token bị từ chối thì dừng.
Mô hình lớn luôn góp thêm 1 token (token sửa, hoặc token kế tiếp khi nhận hết)."""
n = 0
while n < gamma and rng.random() < alpha:
n += 1
return n + 1
if __name__ == "__main__":
tu = ["mèo", "chó", "cá"]
p = [0.5, 0.3, 0.2] # mô hình lớn
q = [0.2, 0.6, 0.2] # mô hình nháp
pd, beta = phan_phoi_dau_ra(p, q)
print("Xác suất nhận token nháp:", round(beta, 4))
print("Phân phối đầu ra:", dict(zip(tu, np.round(pd, 4).tolist())))
rng = np.random.default_rng(0)
dem = np.bincount([lay_mau_mot_buoc(np.array(p), np.array(q), rng)[0] for _ in range(200_000)], minlength=3)
print("Lấy mẫu 200000 lần:", dict(zip(tu, np.round(dem / dem.sum(), 3).tolist())))
for alpha, gamma in ((0.75, 7), (0.6, 4)):
tb = np.mean([mo_phong_mot_luot(alpha, gamma, rng) for _ in range(100_000)])
print("alpha = %.2f, gamma = %d: kỳ vọng %.4f token mỗi lượt, mô phỏng %.4f" % (alpha, gamma, so_token_ky_vong(alpha, gamma), tb))
for c in (0.05, 0.2, 0.8):
tot = max(range(1, 16), key=lambda g: he_so_tang_toc(0.75, g, c))
print("alpha = 0.75, c = %.2f: gamma tốt nhất %d, tăng tốc %.2f lần" % (c, tot, he_so_tang_toc(0.75, tot, c)))
Với ví dụ ba từ, xác suất nhận là 0,7 và phân phối đầu ra đúng bằng (0,5; 0,3; 0,2); lấy mẫu thật cho (0,5; 0,3; 0,199). Với α = 0,75 và γ = 7, công thức cho 3,5995 token mỗi vòng, mô phỏng được 3,5951. Ba dòng cuối cho thấy vai trò của c: với c = 0,05 nên đoán 7 token và nhanh 2,67 lần; c = 0,2 chỉ nên đoán 3 token, nhanh 1,71 lần; c = 0,8 lớn hơn α thì dù chọn γ thế nào cũng chậm hơn chạy thường.
Dùng trong LM Studio và llama.cpp
Tài liệu LM Studio (đọc 12/11/2026) ghi điều kiện quan trọng nhất: mô hình nháp phải có cùng bộ từ vựng với mô hình chính. Cách dễ nhất là chọn bản nhỏ của cùng họ, như Llama 3.1 8B Instruct với Llama 3.2 1B Instruct, hay Qwen 2.5 14B Instruct với Qwen 2.5 0.5B Instruct. Tài liệu gợi ý cỡ mô hình nháp tối đa còn có lợi: khoảng 1B cho mô hình chính 7B, 3B cho 14B, 7B cho 32B. Tốc độ thay đổi theo từng câu hỏi: hỏi công thức nghiệm phương trình bậc hai thì mô hình nhỏ và lớn đều viết giống nhau nên được nhận nhiều; viết truyện thì mỗi chữ có hàng trăm cách tiếp hợp lý nên hay bị từ chối. Chạy thêm mô hình nháp cũng tốn thêm tài nguyên, và nếu nháp không đủ nhanh hay đủ đúng thì tốc độ có thể giảm.
Tài liệu llama.cpp (đọc 12/11/2026) cho llama-server chọn mô hình nháp bằng tùy chọn --model-draft, và số token nháp tối đa mỗi vòng (--spec-draft-n-max) mặc định là 3. Ngoài mô hình nháp, llama.cpp còn có các cách đoán không cần mô hình thứ hai, dựa trên các chuỗi n-gram đã xuất hiện, hợp với việc như viết lại mã nguồn khi đầu ra lặp nhiều đoạn của đầu vào; và EAGLE-3, một mô hình nháp một lớp đọc trạng thái ẩn của mô hình chính nên được nhận nhiều hơn.
- Ghép mô hình nháp khác bộ từ vựng với mô hình chính: token nháp không cùng nghĩa với token của mô hình lớn.
- Chọn mô hình nháp quá lớn: đoán đúng hơn nhưng chậm, c tiến gần α thì không còn lợi.
- Đặt số token nháp mỗi vòng quá cao cho việc sáng tạo: phần lớn bị từ chối, chỉ tốn công.
- Nghĩ rằng giải mã suy đoán làm câu trả lời kém đi: với phép nhận, từ chối đúng, phân phối đầu ra không đổi.
Câu hỏi thường gặp
Speculative decoding là gì?
Là cách để một mô hình nhỏ đoán trước vài token và mô hình lớn kiểm cả loạt trong một lượt chạy, nhờ đó sinh chữ nhanh hơn mà đầu ra vẫn đúng phân phối của mô hình lớn.
Giải mã suy đoán có làm thay đổi câu trả lời không?
Không, nếu dùng đúng phép nhận với xác suất min(1, p/q) và lấy lại từ phần dư. Bài báo của Chen và cộng sự ghi phân phối được giữ nguyên trong giới hạn sai số số học của phần cứng.
Mô hình nháp cần những gì?
Cùng bộ từ vựng với mô hình chính, nhỏ hơn nhiều để chạy nhanh, và đủ tốt để token của nó hay được nhận.
Khi nào không nên bật?
Khi máy thiếu bộ nhớ cho mô hình thứ hai, khi việc cần làm quá sáng tạo nên tỉ lệ nhận thấp, hoặc khi mô hình nháp chạy không đủ nhanh so với mô hình chính.
Học tiếp
Giải mã suy đoán thường đi cùng các cách khác để chạy mô hình lớn trên máy nhỏ: bài lượng tử hóa mô hình giảm bộ nhớ cho trọng số, bài KV cache nói về bộ nhớ của ngữ cảnh. Nếu muốn học AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.
Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.
Nguồn tham khảo
- Leviathan, Kalman, Matias (2023), Fast Inference from Transformers via Speculative Decoding, ICML 2023, arXiv 2211.17192v2 (PDF, đọc 12/11/2026)
- Chen và cộng sự (2023), Accelerating Large Language Model Decoding with Speculative Sampling, arXiv 2302.01318v1 (PDF, đọc 12/11/2026)
- LM Studio Docs: Speculative Decoding (đọc 12/11/2026)
- llama.cpp: docs/speculative.md (đọc 12/11/2026)


