投机解码：草稿小模型 + 大模型并行验证的无损加速

可视化演示

展示零知识证明的三步交互协议（承诺-挑战-响应），通过多轮交互降低欺骗概率，验证者无需获取额外信息即可确信声明真实性。

动机与原理：主厨的瓶颈

让我们回到那家餐厅观察主厨的工作节奏。主厨（大模型）炖一锅高汤要三个小时，更让人头疼的是，每往汤里加一种香料（生成一个 token），主厨都必须重新品一遍整锅汤——因为他的配方规则是：每加一味料，都要回顾前面所有料的味道。这个规则叫自回归：第 t 个字依赖于它之前的所有 t-1 个字。在 Transformer 大模型里，每生成一个 token 都要做一次完整的前向传播（forward pass），把整段上下文重新“读”一遍。

虽然 KV 缓存优化了部分重复计算，但单步开销依然与模型参数量成正比。一个 70B 参数的模型，生成第 100 个 token 和第 1 个 token 的前向计算量几乎一样大。也就是说，生成 T 个 token 就要做 T 次大前向，“出一字、算一遍”是解码延迟的根本瓶颈。而更扎心的事实是：每一次前向都要把全部参数读一遍，但最终只用到了一个 token 的预测结果，大部分算力都花在了“搬家”而不是“思考”上。

投机解码的朴素洞察由此诞生：既然每一步都绕不开一次前向，而前向的核心产出是给词表里每个词打分，那能不能让一个便宜的小模型先把多步的候选都猜出来，再用大模型的一次前向同时给这些候选打分？这就把 T 次大前向压缩成 1 次大前向加若干次小前向，从根本上绕开了强制串行的路径。

主厨依然保留最终决定权——每一道端出去的菜都必须经过他的认可，只是他不再需要亲手切每一片葱姜蒜了。接下来的章节，我们来看看这位学徒（草稿模型）该怎么挑、怎么写草稿、主厨又该怎么审。

草稿模型选型：如何挑选学徒

选学徒有个铁律：不是越聪明越好，而是要“手快”且“口味贴近主厨”。如果学徒做一道菜比主厨还慢，请他来反而拖慢节奏；如果学徒的口味与主厨南辕北辙，主厨得把每一道菜都推翻重做，等于白请。草稿模型的选型标准对应两个量化指标：一是单步延迟 $t_{\text{small}}$ 必须远小于大模型的 $t_{\text{large}}$；二是草稿分布 q 与目标分布 p 的“口味贴合度”要高，即平均接受率 α 要尽量大。

工程上，草稿模型常见方案有三：直接选用一个小参数的开源模型（如 1B 级别对 70B 级别）；用目标模型蒸馏出的迷你版本；或用 n-gram 等轻量统计模型。它们都不需要改动目标模型——大模型保持完全黑盒，只是在它前面增加一个“预检”环节。草稿模型的训练往往是离线完成的，语料与目标模型越接近，接受率就越高。

选好了学徒，接下来看看学徒如何飞快地写出一长串推荐菜单。

自回归快速生成：学徒连写草稿

学徒写菜单的方式和主厨一样，也是一道菜一道菜地想：“昨天主厨做过烤鸭，那今天他多半会配荷叶饼……”只不过他每想一道菜只需要主厨十分之一的时间。因为他的知识结构（参数量）小得多，每一步的“想”（前向传播）都便宜得多。草稿模型生成 γ 个候选 token 时，会以自己刚生成的前缀为条件逐字采样，这个过程完全复用 KV 缓存——每多生成一个候选，只需要做一次轻量的增量计算，而不需要把前面所有内容重算一遍。

这个阶段的目标不是“正确”，而是“快而合理”：学徒可以大胆地按自己的风格往下编，编错了也没关系，反正后面有主厨把关。γ 通常取 4~5：太小则一次验证的收益有限，太大则一旦草稿写偏，后面大量候选全部作废，浪费写作时间。

学徒洋洋洒洒写下一串菜单：“烤鸭、荷叶饼、甜面酱……”，主厨要开始审了。

并行验证机制：主厨一次审完全部候选

主厨审菜单的方式令人惊喜：他不需要一道菜一道菜地尝——他直接把整份菜单拿在手里，用一秒钟把五道菜的搭配在脑子里完整体验一遍。Transformer 的注意力机制恰好支持这种“一次前向看完整行”：输入是一整串候选 token，输出是每个位置上对词表的打分。这就是并行验证的核心：目标模型把 γ 个候选作为同一个序列喂进去，一次前向传播就能得到 γ 个位置的 logits，再配合 softmax 得到每个位置的分布 p。

得到分布后开始逐位置验证。对第 i 个候选 $\hat{x}_i$，我们同时知道草稿模型给它的概率 $q(\hat{x}_i)$ 和目标模型给它的概率 $p(\hat{x}_i)$：如果大模型比草稿模型更看好这个 token（p ≥ q），就完全信任地接受；如果大模型没那么看好（p < q），则以 p/q 的概率接受。一旦某个候选被拒绝，后面所有候选全部作废，被拒绝的位置从修正分布重新采样，下一轮从该位置重新开始。

主厨的审阅几乎瞬间完成：三道菜盖“过”章，第四道菜画了个“叉”并亲自改写，然后把菜单还给学徒，让他从改写处继续往下编。整个过程，主厨只“出手”一次。

数学等价性证明：为什么无损

细心的人会问：学徒写的菜和主厨改过的菜混在一起，最后的菜单味道还能是“纯正主厨风格”吗？答案是：能。这背后是统计学里著名的拒绝采样（rejection sampling）的妙用。对每个被验证的位置，输出只有两种可能：要么接受草稿模型的 x（概率为 $q(x) \cdot \min(1, p(x)/q(x))$）；要么进入拒绝分支，从修正分布 r 里重新采样。把两条路加起来，恰好得到 p(x)——也就是大模型自己采样的分布，分毫不差。

直观理解：当 p(x) > q(x) 时，说明大模型比草稿模型更喜欢 x，草稿“漏掉”的概率质量全部由拒绝分支里的 r(x) 补回来；当 p(x) < q(x) 时，草稿“多给”的概率质量又恰好被 min(1, p/q) 的接受率削掉。一加一减，误差被精确抵消。这就是“无损”二字的数学保证——修正拒绝采样让整体输出分布严格等于目标模型分布。

主厨盖章的每一道菜，和主厨亲手做的每一道菜，在“风味分布”上完全等价。加速归加速，品质不打折——这比任何近似加速方法都更让人安心。

加速收益与工程：餐厅账本的秘密

请了学徒后，餐厅到底快了多少？这取决于两个数：学徒每轮能写出 γ 道菜（草稿长度），以及主厨平均能放行几道（期望接受长度 E[N]）。如果主厨平均放行 2.5 道，主厨此前每出一道菜要 1 分钟、学徒写一道菜只要 0.1 分钟、主厨审一次只要 1 分钟，那么一轮的耗时是 $0.1 \times \gamma + 1$ 分钟，产出却是 2.5 道菜——等效每道菜耗时从 1 分钟大幅下降。当草稿模型足够小、接受率足够高时，整体解码速度就能稳定提升 2~3 倍。

E[N] 的公式体现两个规律：α 越大，期望接受长度越长；γ 无限增大时，E[N] 趋近上界 $\alpha/(1-\alpha)$。但 γ 不能无限大——草稿写太多，一旦中途被拒，前面的写作时间就白花了。工程实践要点：一是把验证前向纳入系统调度，利用 GPU 的批量能力把多个请求的验证合并执行；二是监控每轮接受率，动态调整 γ 或切换草稿模型；三是与 vLLM、TGI 等服务框架的 paged attention、continuous batching 配合，进一步放大吞吐收益。

餐厅账本上，出菜速度提升了两三倍，而顾客吃到的依然是主厨亲手把关的风味。投机解码不改变模型的任何参数，只改变“谁先写、谁再审”的协作方式——这是工程上极其优雅的一类加速。

AI 应用场景

Python 演示

import numpy as np VOCAB = ['a', 'b', 'c', 'd', 'e']N = len(VOCAB)rng = np.random.default_rng(42) # 目标大模型：一阶马尔可夫转移矩阵 P（"主厨的风味"）P = rng.dirichlet(np.ones(N), size=N) # 草稿小模型：与 P 相近但有偏差（"学徒的口味"）Q = 0.6 * P + 0.4 * np.ones((N, N)) / NQ = Q / Q.sum(axis=1, keepdims=True)  def sample(dist):    return int(rng.choice(N, p=dist))  def speculative_decode(steps, gamma):    """草稿模型生成 gamma 个候选，目标模型一次前向并行验证"""    tokens = [int(rng.choice(N))]    while len(tokens) < steps:        prefix = tokens[-1]        # 阶段1:草稿模型自回归生成候选        cand, ctx = [], prefix        for _ in range(gamma):            x = sample(Q[ctx])            cand.append(x)            ctx = x        # 阶段2:目标模型一次前向得到所有位置分布        p_list = [P[prefix]] + [P[cand[i]] for i in range(gamma - 1)]        # 逐位置验证        idx = 0        while idx < gamma and len(tokens) < steps:            x = cand[idx]            prev = cand[idx - 1] if idx > 0 else prefix            p_x = p_list[idx][x]            q_x = Q[prev][x]            if rng.random() < min(1.0, p_x / q_x):                tokens.append(x)                idx += 1            else:                residual = np.maximum(0.0, p_list[idx] - Q[prev])                residual = residual / residual.sum()                tokens.append(sample(residual))                break    return tokens  def trans_freq(seq):    """统计序列中相邻 token 的转移频率"""    T = np.zeros((N, N))    for a, b in zip(seq, seq[1:]):        T[a, b] += 1    T = T / T.sum(axis=1, keepdims=True)    return T  if __name__ == '__main__':    steps, gamma = 20000, 5    seq = speculative_decode(steps, gamma)    baseline = [int(rng.choice(N))]    for _ in range(steps - 1):        baseline.append(sample(P[baseline[-1]]))     err_sd = np.abs(trans_freq(seq) - P).mean()    err_bl = np.abs(trans_freq(baseline) - P).mean()    print('投机解码 转移偏差:', round(err_sd, 5))    print('直接采样 转移偏差:', round(err_bl, 5))    print('两者同分布(无损):', err_sd <= err_bl * 3)

1. P = rng.dirichlet(np.ones(N), size=N)用 Dirichlet 分布随机生成目标大模型的转移矩阵，模拟“主厨风味”。
2. Q = 0.6 * P + 0.4 * np.ones((N, N)) / N构造草稿小模型：与目标分布相近但有明显偏差，模拟“学徒口味”。
3. x = sample(Q[ctx])草稿模型以自己刚写的前缀为条件，逐个采样生成候选 token。
4. p_list = [P[prefix]] + [P[cand[i]] for i in range(gamma - 1)]模拟目标模型一次前向传播同时得到所有位置的分布，这是并行的关键。
5. if rng.random() < min(1.0, p_x / q_x):核心接受判断：大模型更看好就接受，否则按 p/q 比例接受。
6. residual = np.maximum(0.0, p_list[idx] - Q[prev])拒绝后从 max(0, p-q) 归一化分布重采样，把草稿漏掉的概率补回来。
7. err_sd <= err_bl * 3比较投机解码与直接采样的转移矩阵误差，验证两者同分布、无质量损失。

常见误区

面试题