1.1 顺序生成问题#

1
# 自回归生成的瓶颈
2
for i in range(max_tokens):
3
    # 每个 token 依赖于前一个
4
    next_token = model.predict_next(prev_token)
5
    tokens.append(next_token)
6
    prev_token = next_token  # 串行！

自回归模型的生成过程天然是串行的：第 $t$ 个 token 的生成依赖于前 $t-1$ 个 token 的完整上下文。这意味着无论 GPU 的并行计算能力有多强，生成过程都无法突破这一顺序依赖。

1.2 内存带宽墙#

即使计算足够快，内存带宽成为瓶颈：

• 每个 token 需要加载整个模型权重
• 对于 70B 模型，仅加载权重就需要 ~140GB/s
• GPU 的计算利用率（MFU）在 batch_size=1 时通常低于 10%

这说明自回归推理是 memory-bandwidth bound（内存带宽受限），而非 compute bound（计算受限）。每次前向传播只产生一个 token，但需要读取全部模型参数，造成了巨大的带宽浪费。

关键洞察：如果能批量处理多个 token 的验证，就能将多次内存读取合并为一次，充分利用 GPU 的并行计算能力——这正是 Speculative Decoding 的出发点。

2.1 核心思想#

投机解码使用两阶段方法：

2.2 Draft-Verify 流水线#

完整的 Speculative Decoding 可以看作一个流水线：draft 阶段自回归地生成 $k$ 个候选 token，verify 阶段用大模型一次前向传播同时验证所有候选 token。

2.3 验证过程#

1
def speculative_decoding(draft_model, verify_model, x, k=4):
2
    # Stage 1: Draft model 并行生成
3
    draft_tokens = []
4
    draft_probs = []
5
    x_draft = x
6
    for _ in range(k):
7
        logits = draft_model(x_draft)
8
        probs = softmax(logits[-1])
9
        next_tok = sample(probs)
10
        draft_tokens.append(next_tok)
11
        draft_probs.append(probs[next_tok])
12
        x_draft = concat(x_draft, next_tok)
13

14
    # Stage 2: Verify model 批量验证
15
    # 关键：一次前向传播获取所有位置的 logits
16
    all_logits = verify_model(x.extend(draft_tokens))
17

18
    # Stage 3: 接受或拒绝
19
    accepted = 0
20
    for i, tok in enumerate(draft_tokens):
21
        prob_verify = softmax(all_logits[len(x) + i - 1])[tok]
22
        prob_draft = draft_probs[i]
23

24
        # 基于概率比接受
25
        if random() < min(1, prob_verify / prob_draft):
26
            accepted += 1
27
        else:
28
            # 拒绝时从修正分布中重新采样
29
            residual_probs = relu(softmax(all_logits[len(x) + i - 1]) - draft_probs_list[i])
30
            tok = sample(normalize(residual_probs))
31
            break
32

33
    return draft_tokens[:accepted] + [tok] if accepted < k else draft_tokens

2.4 概率接受准则#

关键洞察：接受概率 = min(1, P_verify / P_draft)

• 如果大模型也预测该 token → 接受
• 如果大模型更可能 → 一定接受
• 如果大模型不太可能 → 可能拒绝
• 保证输出与原模型完全相同分布

3.1 条件概率接受#

数学上证明了：

$P(\text{接受 draft token}) = \frac{P_{\text{verify}}(t|x_{<i})}{P_{\text{draft}}(t|x_{<i})}$

当 draft model 与 verify model 一致时，100% 接受。实际上，即使 draft model 远小于 target model，只要两者的输出分布”方向大致一致”（在 top-k token 上重叠），接受率就能保持在较高水平。

3.2 期望接受长度#

设每个 draft token 的平均接受率为 $\alpha$，draft 长度为 $k$，则期望接受的 token 数为：

$E[\text{accepted}] = \frac{1 - \alpha^{k+1}}{1 - \alpha}$

当 $\alpha = 0.85, k = 5$ 时，期望接受约 4.0 个 token。即使偶尔全部拒绝，平均也能获得接近 $k$ 的加速效果。

3.3 速度提升分析#

3.4 实际效果#

1
# 实际测试 (LLaMA 70B + LLaMA 7B)
2
# k=5, 典型序列长度 512 tokens
3

4
results = {
5
    "draft_accept_rate": 0.85,
6
    "speedup": 3.2,  # 3.2x 加速
7
    "tokens_per_second": 45,  # vs 14 baseline
8
    "draft_model_overhead": "10-15% 单步时间",  # draft 生成开销
9
}

4.1 推荐模型组合#

选择合适的 draft model 是 Speculative Decoding 成功的关键。核心原则是：draft model 要足够好以保证高接受率，又要足够快以保证整体加速。

4.2 Draft Model 选择标准#

• 架构兼容：推荐同系列模型（如 LLaMA + LLaMA），架构差异会导致分布差异
• 大小比例：draft model 参数通常为 target model 的 5%-15%（即 7-20 倍大小差异）
• 速度要求：draft model 单步推理时间应 < target model 的 10%，否则无法获得显著加速
• 内存约束：draft model 最好能完全放入 GPU SRAM，避免额外内存访问开销

4.3 大小比例与接受率的权衡#

1
参数比太小 (<5:1)  → draft 慢，开销大，加速不明显
2
参数比太大 (>20:1) → draft 差，接受率低，浪费验证
3
参数比适中 (8-12:1) → 平衡速度与准确率，最优区间

4.4 训练专门的 Draft Model#

一些工作探索了为特定 target model 蒸馏训练专用 draft model：

• 知识蒸馏：用 target model 的输出分布训练小 model
• Top-K 对齐：重点对齐 top-k token 的排序，而非整个词表
• Medusa Heads：直接在 target model 上训练额外的预测头（见变体章节）

5.1 Self-Speculative Decoding#

不需要单独的 draft model，用同一个模型的不同层作为 draft：

1
# 使用浅层作为 draft，深层作为 verify
2
def self_speculative(model, x, draft_layers=12, verify_layers=24):
3
    # Draft: 仅执行前 12 层
4
    draft_logits = model(x, layers=slice(0, draft_layers))
5
    draft_tokens = sample(draft_logits)
6

7
    # Verify: 执行全部 24 层
8
    verify_logits = model(x.extend(draft_tokens), layers=slice(0, verify_layers))
9
    # 验证...

优势：

• 无需加载额外的 draft model，节省显存
• 浅层与深层共享参数，分布天然更接近
• 实现简单，部署友好

劣势：

• 浅层输出质量有限，接受率通常低于专用 draft model
• 需要模型支持中间层输出（layer-skipping）
• 典型加速比：1.5-2.0x

代表工作：Google 的 Self-Speculative Decoding (2023) 在 PaLM 上实现了约 1.6-2.0x 的加速。

5.2 Medusa：多头并行预测#

Medusa 使用多个独立的预测头，并行预测多个未来 token，避免串行 draft 生成：

1
# Medusa 架构
2
class MedusaModel(nn.Module):
3
    def __init__(self, base_model, num_heads=5):
4
        self.backbone = base_model  # 原始 LLM backbone 冻结
5
        self.medusa_heads = nn.ModuleList([
6
            nn.Sequential(
7
                nn.Linear(hidden, hidden),
8
                nn.SiLU(),
9
                nn.Linear(hidden, vocab_size)
10
            ) for _ in range(num_heads)
11
        ])
12

13
    def forward(self, x):
14
        hidden = self.backbone(x).last_hidden_state  # 共享表示
15

16
        # 每个 head 独立预测第 i 个未来 token
17
        draft_tokens = []
18
        for i, head in enumerate(self.medusa_heads):
19
            logits = head(hidden)  # Head 0 → x_{t+1}, Head 1 → x_{t+2}, ...
20
            draft_tokens.append(sample(logits))
21

22
        return draft_tokens

核心区别：

训练方法：

Medusa head 的训练采用两阶段策略：

1. 阶段一：冻结 backbone，仅训练 Medusa heads，使用 teacher-forcing loss
2. 阶段二（可选）：联合微调 backbone + heads，提升接受率

5.3 EAGLE：特征级草稿#

EAGLE (Extrapolation Algorithm for Greater Language-model Efficiency) 的核心创新是在**特征层面（feature-level）**而非 token 层面进行 draft：

1
# EAGLE 的核心思路（简化版）
2
class EAGLEDraft:
3
    def __init__(self, target_model):
4
        self.target = target_model
5
        self.draft_net = AutoRegressiveHead(
6
            input_dim=hidden * 2,  # 拼接 [特征, token embedding]
7
            output_dim=hidden,
8
        )
9

10
    def draft(self, x, features_history):
11
        """基于历史特征序列自回归地生成 draft 特征"""
12
        draft_features = []
13
        feat = features_history[-1]
14
        for _ in range(k):
15
            # 利用上下文特征 + token embedding 联合预测
16
            next_feat = self.draft_net(concat(feat, embedding(last_token)))
17
            draft_features.append(next_feat)
18
            feat = next_feat
19

20
        # 将 draft 特征送入 target model 的最后几层进行验证
21
        # 只需执行少量层即可，大幅减少计算量

EAGLE 的关键优势：

• 在特征空间做 draft：利用 target model 的中间表征（而非词表分布），信息更丰富
• 自回归地生成特征：保持了序列依赖关系，接受率显著高于 Medusa
• 验证开销小：只需将 draft 特征通过 target model 的最后几层，而非完整前向传播

性能对比：

5.4 其他变体#

• Staged Speculative Decoding：多级 draft（小模型 → 中模型 → 大模型），逐级验证
• SpecInfer：树形 draft 结构，同时考虑多个候选路径
• BiLD (Bi-directional Latent Draft)：利用双向上下文提升 draft 质量
• Cascade Speculative Decoding：在多轮对话中复用 draft model 的 KV Cache

6.1 主流方法性能对比#

以下是在常见 benchmark 上的性能数据（单卡 A100-80G，batch_size=1）：

6.2 不同 draft 长度 k 的影响#

1
k=3:  加速比 2.3x  | 延迟波动小，适合对尾延迟敏感的场景
2
k=5:  加速比 3.2x  | 综合最优，大多数场景推荐
3
k=8:  加速比 3.4x  | 略高于 k=5，但拒绝时浪费更多计算
4
k=12: 加速比 3.3x  | 开始下降，边际收益递减

$k$ 的最优值取决于接受率 $\alpha$，理论最优约为 $k^* \approx -1/\log(\alpha)$。当 $\alpha=0.85$ 时，$k^* \approx 6$。

6.3 不同任务的表现差异#

7.1 vLLM 中的配置#

vLLM 从 v0.3.0 开始支持 Speculative Decoding，配置非常简洁：

1
from vllm import LLM, SamplingParams
2

3
# 基本配置
4
llm = LLM(
5
    model="meta-llama/Llama-2-70b-hf",
6
    speculative_model="meta-llama/Llama-2-7b-hf",  # draft model
7
    num_speculative_tokens=5,  # draft 长度 k
8
    speculative_draft_tensor_parallel_size=1,  # draft model 用单卡
9
    tensor_parallel_size=4,  # target model 用 4 卡
10
)
11

12
sampling_params = SamplingParams(
13
    temperature=0.0,  # greedy 时加速效果最好
14
    max_tokens=512,
15
)
16

17
outputs = llm.generate(["解释量子计算的原理"], sampling_params)

vLLM Speculative Decoding 关键参数：

性能调优建议：

• temperature=0（贪心解码）时加速效果最好，因为 draft 和 target 都确定性地选择 top-1
• 高温度采样时接受率下降，但仍能获得 2x 左右加速
• 建议在 batch_size 较小的在线推理场景使用，batch 较大时 GPU 已充分利用，加速效果有限

7.2 HuggingFace Transformers#

1
from transformers import AutoModelForCausalLM, AutoTokenizer
2
import torch
3

4
# 加载 target model（量化以节省显存）
5
target_model = AutoModelForCausalLM.from_pretrained(
6
    "meta-llama/Llama-2-70b-hf",
7
    load_in_4bit=True,
8
    device_map="auto",
9
)
10

11
# 加载 draft model
12
draft_model = AutoModelForCausalLM.from_pretrained(
13
    "meta-llama/Llama-2-7b-hf",
14
    device_map="auto",
15
)
16

17
# 从 v4.36+ 开始支持 assisted_decoding
18
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-70b-hf")
19
inputs = tokenizer("解释量子计算的原理", return_tensors="pt").to("cuda")
20

21
outputs = target_model.generate(
22
    **inputs,
23
    assistant_model=draft_model,  # 指定 draft model
24
    max_new_tokens=512,
25
    do_sample=False,
26
)

7.3 TensorRT-LLM 部署#

NVIDIA TensorRT-LLM 也原生支持 Speculative Decoding：

1
# TensorRT-LLM 配置示例
2
# 需要分别构建 target 和 draft engine
3
trtllm-build \
4
    --model_dir meta-llama/Llama-2-70b-hf \
5
    --output_dir engines/target/ \
6
    --tp_size 4
7

8
trtllm-build \
9
    --model_dir meta-llama/Llama-2-7b-hf \
10
    --output_dir engines/draft/ \
11
    --tp_size 1
12

13
# 推理时启用 speculative decoding
14
# 在 pyT runtime 中配置 draft_model_path 和 speculative_length

7.4 部署注意事项#

1. 显存规划：需要同时加载 target model 和 draft model，总显存需求约增加 10-15%
2. KV Cache 管理：拒绝 token 后需要回滚 KV Cache，确保框架支持此操作
3. 动态 batch：在连续批处理（continuous batching）场景下，draft token 拒绝会导致序列长度变化，需要框架层面支持
4. 延迟 vs 吞吐：Speculative Decoding 更适合延迟敏感的单请求场景；高吞吐场景下 batch 已经很大，加速效果有限

9.1 Q1： Speculative Decoding 会改变模型输出吗？#

不会。这是 Speculative Decoding 最核心的保证。概率接受准则 + 拒绝时修正分布重采样的机制，在数学上严格证明了最终输出分布与 target model 完全一致。无论 draft model 质量如何，输出质量不会下降——只会影响速度。

9.2 Q2： draft model 和 target model 必须是同一系列吗？#

不是必须，但强烈推荐。理论上任何模型组合都可以，但不同系列的模型在 token 选择偏好上差异较大，会导致接受率显著下降。例如用 GPT-2 作为 LLaMA 的 draft model，接受率可能低于 50%。同系列模型（LLaMA + LLaMA）共享相似的分布特征，接受率通常 >80%。

9.3 Q3： 什么时候不适合使用 Speculative Decoding？#

以下场景不建议使用：

• 高吞吐离线推理：batch_size 较大时 GPU 已经充分利用，加速效果有限甚至可能降低吞吐
• 创意写作等高温度采样：高温度下分布更均匀，draft 和 target 的 top-k 重叠减少
• 极端资源受限：无法同时加载两个模型的场景
• MoE 模型：MoE 的活跃参数较少，target 本身推理速度已较快，加速空间有限

9.4 Q4： draft 长度 k 应该怎么设置？#

推荐从 $k=5$ 开始，然后根据实际接受率调整：

• 如果接受率 >90%，可以尝试增大到 $k=8$
• 如果接受率 <75%，降低到 $k=3$
• 理论最优值约为 $k^* = -1 / \ln(\alpha)$

9.5 Q5： Medusa 和标准 Speculative Decoding 该选哪个？#

• 资源充足、追求最高加速：标准 Speculative Decoding（接受率更高）
• 显存受限、追求低延迟：Medusa（额外参数 <1%，无需加载额外模型）
• 追求最佳综合效果：EAGLE（接受率高 + 显存开销适中）

9.6 Q6： Speculative Decoding 能和量化一起用吗？#

可以。draft model 和 target model 都可以独立使用量化技术（如 GPTQ、AWQ、GGUF）。一个常见配置是 target model 使用 4-bit 量化、draft model 使用 FP16，这样整体显存开销很低，同时 draft model 保持较高精度以保证接受率。

9.7 Q7： batch 推理时能用 Speculative Decoding 吗？#

可以，但加速效果会随 batch_size 增大而递减。原因是 batch 较大时 GPU 计算已经接近饱和，draft 带来的额外计算开销占比更高。通常在 batch_size ≤ 4 时效果最好，batch_size > 16 时加速效果可以忽略。

9.8 Q8： 如何监控 Speculative Decoding 的效果？#

关键监控指标：

• Accept Rate：每个 step 中被接受的 draft token 比例
• Effective Draft Length：平均每个 step 接受的 token 数
• Tokens/s：实际生成速度
• Draft Overhead：draft 生成时间占总推理时间的比例

如果 Accept Rate 持续低于 70%，应该检查 draft model 是否合适或降低 k 值。

9.1 Speculative Decoding 会改变模型输出吗？#

不会。数学上证明了 Speculative Decoding 的输出分布与原始模型完全一致。接受准则保证了采样等价性。

9.2 什么场景下 Speculative Decoding 效果最好？#

① 批处理大小为 1 或较小的推理；② Draft model 和 target model 风格相似（同系列模型）；③ 输出确定性较高的任务（翻译、摘要）；④ GPU 利用率较低的推理（内存带宽受限）。

9.3 接受率一般有多高？#

使用同系列模型作为 draft（如 LLaMA 7B → LLaMA 70B），典型接受率 70-90%。Token 级别的接受率更高（>85%）。接受率越高，加速比越大。

9.4 Speculative Decoding 和 KV Cache 量化可以一起用吗？#

可以。两者优化不同瓶颈：Speculative Decoding 减少 token 生成次数，KV Cache 量化减少内存带宽占用。结合使用可叠加加速效果。