跳到主要内容

投机采样

前面的推理优化——KV Cache、量化、FlashAttention——都是在压榨"单次前向传播"的开销。但 LLM 有个更本质的问题:它一次只能吐一个 token。你要 100 个 token 的输出,就得跑 100 次前向。这个自回归的顺序是"天生的串行",看起来没法并行。

真的没法吗?投机采样(Speculative Decoding) 给出了一个巧妙的答案:让一个小模型先猜,大模型来验证。这个方法让大模型的输出速度可以逼近小模型——几乎白送的 2-3 倍加速。

1. 一个观察:Prefill 和 Decode 的算力差​

回到 KV Cache 那一章的核心观察:

  • Prefill:处理 n 个 token,计算密集,GPU 打得挺满;
  • Decode:每步 1 个 token,访存密集,GPU 大量算力闲置。

Decode 阶段 GPU 只用了几个百分点的算力——它在等数据。这个"闲置算力"就是投机采样能利用的地方。

投机采样的核心问题:如果我一次能处理 k 个 token 的前向(而不是 1 个),会怎样?

答案是——几乎不比 1 个 token 慢。因为瓶颈是权重搬运,不是计算。搬一次权重能覆盖 k 个 token 的计算,只要 k 不太大,时间几乎不变。

所以:如果我能同时验证 k 个候选 token,就能一步吐出多个 token。这就是投机采样。

2. 基本框架​

投机采样需要两个模型:

  • Draft Model(草稿模型):小、快。生成候选 token 序列。
  • Target Model(目标模型):大、慢。就是你想部署的那个。它负责验证草稿模型的输出。

一次投机迭代:

  1. Draft:草稿模型自回归生成 k 个候选 token:d_1, d_2, ..., d_k。这一步很快,因为草稿模型小。
  2. Verify:目标模型一次前向看这 k 个候选。因为可以并行算 k 个位置的注意力,所以只用一次前向就得到 k 个位置的"应该输出什么"的分布。
  3. Accept/Reject:一个一个对比:草稿模型采样出的 token 和目标模型的分布对上了吗?对上了就接受,不对就在这一步停下、按目标模型的分布重采样。
  4. 回填:接受了 m 个 token(m 可能是 0 到 k+1,考虑最后一步的额外一个 token)。KV Cache 里只保留这 m 个的 KV,丢掉未接受的部分。
  5. 循环。

关键点:一次目标模型的前向传播可以吐出多个 token——如果全接受,一步就吐出 k+1 个。

3. 为什么这样"等价"​

看起来我们在"用小模型采样",输出还能保证和"直接用大模型采样"分布一致吗?

能。这是投机采样最巧妙的地方——接受-拒绝机制保证了最终分布严格等于目标模型自采样的分布。

具体的接受规则(拒绝采样):

草稿模型在某个位置采样的 token 是 d。计算:

  • p(d)p(d):目标模型在该位置对 d 的概率;
  • q(d)q(d):草稿模型在该位置对 d 的概率。

接受概率:min⁡(1,p(d)/q(d))\min(1, p(d)/q(d))。

  • 如果 p(d)≥q(d)p(d) \geq q(d):直接接受(草稿模型对这个 token 不够自信,目标模型觉得更合理,正好用);
  • 如果 p(d)<q(d)p(d) < q(d):以 p/qp/q 的概率接受,1−p/q1-p/q 的概率拒绝。

拒绝之后重新采样:从修正的分布 max⁡(0,p−q)\max(0, p - q) 归一化里采样一个新 token。

这个操作数学上等价于"直接从 p 里采样"——所以输出分布和目标模型独立采样完全一致。这不是近似加速,是精确加速。

4. 一个直观例子​

假设草稿模型和目标模型对某个位置都很自信,都倾向"猫"这个词:

  • q("猫") = 0.6, q("狗") = 0.3, q("...") = 0.1
  • p("猫") = 0.7, p("狗") = 0.2, p("...") = 0.1

草稿模型采样得到"猫"(概率 0.6)。

对比:p(猫)=0.7 ≥ q(猫)=0.6,接受。这一步等价于用目标模型采样了"猫",但只花了小模型的钱。

如果草稿模型采样得到"狗"(概率 0.3):

对比:p(狗)=0.2 < q(狗)=0.3,接受概率 = 0.2/0.3 ≈ 0.67。骰子决定,1/3 概率拒绝。

如果拒绝,从修正分布 max(0, p-q) = (0.1, 0, 0) → 归一化到 (1, 0, 0) 采样——就是"猫"。

整个过程结束后,得到的分布是:

  • 接受"猫"的概率 = q(猫) × 1 = 0.6
  • 接受"狗"的概率 = q(狗) × 0.67 = 0.2
  • 接受"..."的概率 = q(...) × 1 = 0.1
  • 被拒绝时采样得到的 token 分布 = (1, 0, 0),权重 = 拒绝的概率 = 0.1

加起来:猫的最终概率 = 0.6 + 0.1 × 1 = 0.7;狗 = 0.2;其他 = 0.1。和 p 完全一样。

5. 加速多少​

理想情况下,如果 k 步全接受:

  • 一次投机迭代 = 1 次大模型前向(快)+ k 次小模型前向(更快)
  • 结果:k+1 个 token
  • 时间:约 1 × T_large + k × T_small
  • 平均每 token 时间:(T_large + k · T_small) / (k+1)

假设大模型 100ms/token、小模型 10ms/token、k=5:

  • 朴素:100 × 5 = 500 ms 生成 5 token
  • 投机(全接受):100 + 5 × 10 = 150 ms 生成 6 token
  • 加速比 3.3 倍

实际接受率一般在 60-80%(不是全接受),加速比大概 2-3 倍。这是一个已经在很多推理框架里落地的收益。

6. Draft Model 从哪来​

草稿模型要满足两个条件:

  • 足够小、足够快——不然预算全花它身上了;
  • 和目标模型的分布足够接近——不然接受率太低,加速失效。

几种常见选择:

大目标 + 小模型对:Qwen-72B 目标 + Qwen-1.5B 草稿。同一家训练、tokenizer 一样,分布接近。

"n-gram head":非常轻的草稿——直接从上文里抓 n-gram。比如你正在生成代码,前面出现过 def foo():,n-gram 猜测后面很可能接 \n return。零成本,接受率不高但也白得一点。

Draft 是目标的"轻量版":Medusa、Eagle 等方案是给目标模型加一些额外的"预测头",让它一次前向就能预测多个未来 token。不用独立的小模型,但需要额外训练。

7. 一些常见变种​

投机采样从提出之后衍生了很多变种:

SpecDec(原始版本):Google 2022 提的第一个可用方案。

Medusa:Together AI 提出。给目标模型的最后一层加几个 head——head_1 预测下一个 token、head_2 预测下下个、head_3 预测下下下个……一次前向出多个"候选序列"。不用额外模型,训练一小时就好。

Eagle:一个专门为投机采样设计的小模型架构。用目标模型的中间层特征作为输入,训出来的接受率比传统 draft model 高。

Lookahead Decoding:不需要草稿模型,直接用一种"n-gram + Jacobi 迭代"的方式并行推理。零外部模型开销。

PLD(Prompt Lookup Decoding):极致简单版——直接把 prompt 里的片段当草稿。适合"长上下文 + 输出跟输入高度相关"的任务,比如代码补全、翻译。

vLLM、TGI、SGLang、TensorRT-LLM 都支持投机采样。开源和商业推理框架都在集成。

8. Multi-token Prediction:训练侧的相关工作​

投机采样是推理时的技巧。训练时也有一个类似思想——Multi-Token Prediction (MTP):

一次训练不是预测下一个 token,而是一次预测多个未来 token——比如同时预测 t+1, t+2, t+3。

DeepSeek-V3 就用了 MTP 训练。好处有两个:

  • 训练信号更密集:每个位置提供多个训练目标,参数利用率更高;
  • 天然带自己的 draft model:MTP 训出来的模型自带"一次预测 k 步"的能力,用作投机采样的草稿几乎零成本。

训练时 MTP + 推理时投机采样 = 特别顺畅的组合。这是 DeepSeek-V3 推理速度快的一部分原因。

9. 一些实用细节​

接受率是关键指标。看你的 draft/target 组合表现如何,衡量指标是"平均一次投机接受多少个 token"。这个数字:

  • < 1:投机没意义,反而变慢;
  • 1-2:小幅加速;
  • 2-4:显著加速,1.5-2.5 倍;
  • 4+:极强,加速可能到 3 倍以上。

一般 draft 越接近 target 分布,接受率越高。同架构 + 同 tokenizer 的模型对最好。

k 值调节。k 是"每次投机多少步"。太小加速有限,太大浪费(因为后面的接受率随距离降低)。一般 k=4-8 是合适范围。

Temperature 会影响接受率。低温度(贪心倾向)下模型分布集中,投机接受率高;高温度(发散)下分布更平,接受率低。这也是"投机采样在代码任务上加速更大"的原因——代码温度低。

长上下文下投机效果打折。因为长上下文时目标模型的每 token 成本上升,但小 draft 模型的成本上升相对更小——比例会变化。

批处理 vs 投机。大 batch 下,目标模型本身已经吃满了带宽,投机的收益变小。极端 batch 场景下投机可能不划算。中低并发场景(延迟敏感)投机收益最大。

10. 什么时候用、什么时候不用​

特别适合投机的场景:

  • 单请求延迟敏感:交互式对话、代码补全——每个 token 越快越好;
  • 草稿和目标很相似:同架构小模型;
  • 低温度:代码、格式化输出、翻译;
  • 短上下文(< 8K);

不太适合投机的场景:

  • 超高并发:batch 已经把 GPU 打满了,投机没有闲置算力可用;
  • 超高温度:随机性大,接受率低;
  • 超长上下文:小 draft 模型的成本也变高,占比变差;
  • 目标模型本身就小:小模型的 decode 已经很快了,加速空间有限。

11. 一个更宏观的视角​

投机采样的成功也源于一个观察:LLM 生成里绝大多数 token 都很"容易"。

比如你让模型写 Python:def add(a, b): 后面几乎肯定接 \n return a + b。这些"容易"的 token 用小模型就能猜对——只有偶尔的"关键决策 token"才需要大模型。

投机采样是把"容易 token 用小模型"和"难 token 用大模型验证"自然融合。这个思路可能会推广——比如分层 MoE、依难度动态路由都是类似的想法。根据 token 难度自适应算力是 LLM 推理的下一个大方向。

12. 一句话总结​

投机采样是当前 LLM 推理里最漂亮的加速技巧:

  • 原理:小模型猜,大模型验证;小模型对了就接受,错了就纠正;
  • 保证:输出分布严格等于大模型自采样;
  • 加速:2-3 倍是常见收益,甚至更多;
  • 依赖:draft model 分布接近 target,且 GPU 有闲置算力。

它揭示了 LLM 推理的一个深层特性——大部分 token 的生成"不难",浪费大模型算力。让容易的用小模型跑、难的用大模型跑,这个思路会在未来越来越多的地方出现。


到这里,我们把 LLM 的一整套体系都过完了:

  • 架构:Transformer、Tokenizer;
  • 训练:预训练、SFT、RLHF、LoRA;
  • 推理:KV Cache、采样、FlashAttention、量化、投机采样。

每一环都是一个可以深挖的方向。不过掌握了这些基础,你已经能大致理解从 GPT-4 到 LLaMA、从训练系统到推理服务背后到底在做些什么了。剩下的都是在这个骨架上不断打补丁、优化细节的过程——LLM 系统的核心,就是把这些基础做扎实。