投机解码：实习生打草稿，专家批量审稿

可视化演示

展示投机解码通过草稿模型快速生成候选Token、主模型批量验证并行接受的加速流程，动态对比标准自回归与投机解码的性能差异。

核心原理：先猜后审

王老师打字奇慢但字字珠玑，小李打字飞快但错漏百出。项目经理发现，王老师“审稿”的速度比“亲自写稿”快得多，于是设计了新流程：小李先快速起稿一整页，王老师一次性扫读整页，写得顺眼的地方直接放行，不顺眼的地方亲笔改写。这样既保住了王老师的文字水准，又省下了逐字斟酌的时间。

这套流程正是投机解码的骨架。自回归大模型在生成 token 时必须逐字串行，每一步都做一次昂贵的前向传播，这是延迟的根源。投机解码引入一个又快又小的草稿模型（draft model），让它一口气猜出 N 个候选 token；然后主模型（target model，也就是被加速的大模型）对这些候选做“批量验证”——只花一次前向传播的时间，同时得到 N 个位置的预测分布，并按照投机采样规则接受或拒绝候选。

验证规则非常优雅：主模型按概率接受草稿 token；一旦遇到第一个被拒绝的 token，就从这个位置开始由主模型重新采样一个 token，并丢弃它身后的所有草稿。因为“审稿”只花一次前向传播的时间，却能换来多个被接受的 token，推理延迟显著下降。假设每个 token 的接受概率为 \(\gamma\)，每轮猜 N 个，那么每轮期望生成 token 数为：

这套“先猜后审”的思路，本质就是把专家的时间从“逐字写作”变成“整页审稿”。任何依赖自回归逐 token 生成的大模型推理场景，都能借用这条流水线。

草稿模型：选对实习生

实习生不是随便招的。小李每天模仿王老师的措辞风格，三个月后与王老师的“口味”越来越接近。选草稿模型也一样——关键不是单纯地小，而是它的输出分布要足够接近主模型。如果实习生只会写火星文，王老师每行都要重写，新流程反而比原来更慢。

草稿模型的选择通常有三条路线。第一条是“同族小模型”：从主模型蒸馏、剪枝或缩小层数得到的小版本，比如用 Llama 系小模型给 Llama-2-70B 打草稿，师出同门、分布天然亲近。第二条是“独立小模型”：任何分布接近主模型的小模型都可以，即使架构不同。第三条是“训练对齐”：无论选哪个小模型，都要用主模型的输出分布做蒸馏，让草稿模型学会“专家的笔迹”。

参数规模上，草稿模型一般取主模型的 0.1 到 1 倍。太小则猜测质量差、接受率低；太大则草稿阶段的计算成本反客为主。训练草稿模型的核心目标函数是蒸馏损失，也就是让草稿分布 \(q\) 尽量贴合主模型分布 \(p\)：

请一个和王老师口风一致的实习生，审稿通过率才高。这也解释了为什么投机解码论文里，草稿模型一定要“像”主模型，而不是随便拿个通用小模型硬凑。

猜测长度：一次交几页

项目经理渐渐发现，交一页草稿省不了多少时间，交十页又容易在后几页大量出错被王老师划掉重写，得找到一个折中。这个“折中”就是投机解码里的猜测长度 \(N\)——每轮草稿模型一口气生成的候选 token 数量。

\(N\) 越大，单轮潜在收益越大，但超过一定长度后，后续 token 的接受概率会随 \(\gamma^N\) 指数衰减。比如 \(\gamma=0.8\) 时，第 5 个候选被全部接受的联合概率只有 \(0.8^5 \approx 0.33\)，后半段草稿几乎全是无效劳动，还白白占用草稿模型的计算时间。反过来，\(N\) 太小，专家省下的时间有限。

实践中 \(N\) 一般取 4 到 8。更聪明的实现会自适应调整：记录最近若干轮的接受率，接受率高就加长猜测长度，接受率低就缩短。最优长度可以通过最大化“每轮收益与成本之比”来刻画：

一次传两盘菜效率高，一次传二十盘则很容易洒。猜测长度就是传菜盘数，既要让专家一次审得够多，又不能贪多嚼不烂。

接受率优化：让实习生更靠谱

小李的靠谱程度决定一切。若他写的每句话都能让王老师点头，整页草稿几乎全通过；若满纸荒唐言，王老师疲于改稿，流水线反而拖垮产能。在数学上，草稿模型的靠谱程度被量化成接受率 \(\gamma\)。

接受率 \(\gamma\) 等于草稿模型分布 \(q\) 与主模型分布 \(p\) 的“重叠面积”。两个分布重叠得越多，草稿 token 越容易通过验证；完全一致时 \(\gamma=1\)，完全不相干时趋向 0。用公式表达：

影响接受率的因素主要有三个。第一是任务熵：代码补全、数学推导这类“低熵”任务，下一个 token 几乎被语境锁死，草稿容易猜中；而开放性创意写作是“高熵”任务，每个位置都有大量合理选择，草稿很难与主模型重合，接受率自然偏低。第二是解码温度：温度过高会让分布趋于均匀、更“散”，草稿更难命中；温度过低则分布过于尖锐，草稿一旦偏离就几乎必然被拒。第三是训练：通过蒸馏让草稿模型沿着主模型的分布走，直接抬高重叠面积。

温度就像是给实习生“自由发挥程度”的拨盘——拨太高变成自由创作，拨太低则死板照搬。想提高接受率，最根本的办法还是让实习生吃透专家的“批改笔记”。

加速比：效率账本

流水线省下的时间到底有多少？作为项目经理，你得会算这笔账。每轮投机解码的迭代成本是 \(N\) 次草稿模型前向加 1 次主模型验证；而基准方法生成 \(E\) 个 token 需要 \(E\) 次主模型前向。设主模型单步耗时是草稿模型的 \(r\) 倍，那么理论加速比为：

其中 \(E=(1-\gamma^{N+1})/(1-\gamma)\)。这个公式讲了两件事：分子是“每轮审稿能带走多少 token”（收益），分母是“每轮要花多少时间”（成本）。当草稿模型极快（\(r\) 很大）时，分母趋近 1，加速比接近期望生成数；当草稿模型太慢（\(r\) 小），分母变大，加速被草稿成本吃掉。

实际落地时，主流实现报告 2 到 3 倍加速，优化到位的系统（如 Medusa、EAGLE）在低熵任务上可以跑到 3 倍以上。影响实测加速比的因素包括接受率 \(\gamma\)、猜测长度 \(N\)、主模型与草稿模型的速度比 \(r\)，以及批量验证是否真正利用了并行计算。

让王老师从“逐字写作”的瓶颈中解放出来，团队整体产能自然飞跃。但前提是实习生够快、够像，否则这笔账就亏了。

工程实现：流水线细节

纸上谈兵的流程要落地，还得解决三个工程细节。第一个细节是“批量验证”：王老师审稿之所以快，是因为他能一眼扫过一整页；主模型要复现这种“一眼扫过”，就不能逐个 token 重新做前向传播。实现上，Transformer 可以利用因果掩码（causal mask）把 N 个候选位置拼进同一个序列，一次 forward 同时拿到 N 个位置的预测分布。这就是投机解码中“批量验证”的真正含义。

第二个细节是 KV 缓存复用。草稿模型生成 N 个 token 时，主模型验证时可以把上下文部分的 KV cache 直接复用，避免重复计算；验证通过的前缀也能继续贡献给后续轮次。第三个细节是采样一致性。被拒绝的 token 必须从修正分布中重新采样，而不能简单取概率最大的 token——否则生成分布会悄悄偏离主模型。候选序列的联合概率可以写成链式分解，但工程上由一次并行前向高效近似：

流水线的细节决定成败：批量验证让“审稿”快起来，KV 缓存复用让“改稿”不重复劳动，重采样保证“定稿”仍然是专家的真实品味。

适用场景：哪些工作室适合

不是所有工作室都适合这套流水线。如果王老师本身写字快如复印（推理不是瓶颈），或者小李水平太差（\(\gamma\) 太低），流水线反而添乱。判断是否值得上投机解码，核心指标是延迟降幅：

三类场景最受益。第一类是延迟敏感型交互服务：聊天机器人、语音助手、实时翻译，用户每多等一秒都在流失，用投机解码把每次回复的 token 生成延迟砍半，体验提升立竿见影。第二类是高并发 Token 吞吐服务：当服务端被海量请求压满时，减少主模型调用次数直接提升 QPS 和吞吐，摊薄单次请求的 GPU 成本。第三类是端侧与资源受限部署：手机、嵌入式设备算力有限，可以让小草稿模型在本地快速起草，把更少的验证请求发给云端或更大的主模型，兼顾速度与质量。

让王老师从逐字写作的瓶颈中解放出来，团队整体产能飞跃。衡量标准很简单：延迟敏感、并发高、算力紧，这三个信号出现任意一个，投机解码就值得纳入方案选型。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""投机解码（Speculative Decoding）简化模拟草稿模型=实习生(快速但粗糙) 主模型=专家(准确但缓慢)通过批量验证，专家一次审阅 N 个草稿字符，只在自己不满意处改写本示例用字符级 bi-gram 模拟两档"模型"，直观对比两种解码方式""" import random  class DraftModel:    """草稿模型（实习生）：极轻量，只按单字频率均匀地猜下一个字符"""     def __init__(self, vocab, seed=42):        self.vocab = vocab        self.unigram = {c: 1.0 / len(vocab) for c in vocab}        self.rng = random.Random(seed)        self.gc_count = 0   # 调用次数计数器     def sample(self, context):        # 实习生从不看上下文，uniform 乱猜（教学简化）        self.gc_count += 1        return self.rng.choices(self.vocab, [self.unigram[c] for c in self.vocab])[0]  class TargetModel:    """主模型（资深专家）：bi-gram 条件分布，更聪明但更贵"""     def __init__(self, vocab, seed=7):        self.vocab = vocab        self.trans = {            'a': {'a': 0.15, 'b': 0.85},            'b': {'a': 0.90, 'b': 0.10},        }        self.rng = random.Random(seed)        self.gc_count = 0   # 调用次数计数器     def next_dist(self, context):        last = context[-1]        return self.trans.get(last, {c: 1.0 / len(self.vocab) for c in self.vocab})     def verify(self, draft_seq, context):        """批量验证：一次调用同时审阅 N 个草稿字符"""        self.gc_count += 1        accepted = []        q = 1.0 / len(self.vocab)        for ch in draft_seq:            dist = self.next_dist(context + tuple(accepted))            p = dist.get(ch, 1e-9)            if self.rng.random() < min(1.0, p / q):                accepted.append(ch)          # 通过，留下            else:                # 被否决：从修正分布 (p - q)_+ 重新采样，模拟无偏回退                residual = {k: max(v - q, 0.0) for k, v in dist.items()}                total = sum(residual.values())                if total <= 0:                    residual = dist                accepted.append(self.rng.choices(                    list(residual.keys()), list(residual.values()))[0])                break        return accepted     def sample(self, context):        self.gc_count += 1        dist = self.next_dist(context)        return self.rng.choices(list(dist.keys()), list(dist.values()))[0]  def speculative_decode(draft, target, seed_text, max_len=30, N=4):    """跑一轮投机解码，返回生成文本与迭代轮数"""    context = list(seed_text)    steps = 0    while len(context) < max_len:        draft_seq = [draft.sample(tuple(context)) for _ in range(N)]        accepted = target.verify(draft_seq, tuple(context))        context.extend(accepted)        if not accepted:                     # 防御：至少前进 1 步            context.append(target.sample(tuple(context)))        steps += 1    return "".join(context), steps  def baseline_decode(target, seed_text, max_len=30):    """标准自回归：专家一个字一个字写，调用次数等于生成的字符数"""    context = list(seed_text)    while len(context) < max_len:        context.append(target.sample(tuple(context)))    return "".join(context)  def main():    vocab = ['a', 'b']    seed_text = "a"    max_len = 30     t1 = TargetModel(vocab, seed=7)    text1 = baseline_decode(t1, seed_text, max_len)    base_calls = t1.gc_count     d2 = DraftModel(vocab, seed=42)    t2 = TargetModel(vocab, seed=7)    text2, steps = speculative_decode(d2, t2, seed_text, max_len, N=4)    spec_calls = t2.gc_count    draft_calls = d2.gc_count     print("==== 标准自回归 ====")    print("主模型调用次数:", base_calls)    print("生成文本:", text1)    print()    print("==== 投机解码 ====")    print("主模型调用次数:", spec_calls, "，草稿模型调用:", draft_calls)    print("迭代轮数:", steps)    print("生成文本:", text2)    print()    print("主模型调用次数降低: %.1f 倍" % (base_calls / spec_calls))    print("说明：投机解码用大量廉价草稿调用换来了昂贵主模型调用的减少")  if __name__ == "__main__":    main()

1. self.gc_count += 1每调用一次采样就计数一次，用来统计两类模型各自的开销。
2. dist = self.next_dist(context + tuple(accepted))验证第 i 个草稿时，条件要带上已经通过的前缀，体现自回归的链式依赖。
3. if self.rng.random() < min(1.0, p / q)投机采样的接受判定：草稿概率相对主模型概率越高越容易通过，超过 1 则必然接受。
4. residual = {k: max(v - q, 0.0) for k, v in dist.items()}被拒后从修正分布重采样，保证最终输出分布与主模型一致。
5. context.extend(accepted)把这一轮通过的 token 接进真实序列，继续下一轮猜测。

常见误区

面试题