第 1 章：推理加速全景：从计算瓶颈到多路突围¶
训练一个 GPT-4 级模型花费上亿美元，但推理才是持续烧钱的部分——每个用户的每次请求都要完整跑一遍前向传播。推理优化只有一个问题：怎么用更少的计算和内存，更快地生成同样质量的输出。[14][15]
本章从"推理为什么慢"的第一性原理出发，拆解三条加速路径：FlashAttention（让注意力计算不再浪费 IO）、投机解码（让一次大模型调用生成多个 token）、量化（让模型小到装得下、搬得动）。每条路径从数学原理推到工程实践，覆盖 2022–2025 年的核心论文与生产部署数据。
你将收获什么¶
- 一套瓶颈分析框架：从 FLOPs 公式到 Roofline 模型，精确定位推理"慢在哪里"。
- FlashAttention 全系列：理解注意力为何能从 25% GPU 利用率提升到 85%。
- 投机解码的数学与工程：拒绝采样为什么能无损加速，EAGLE 三代架构为什么越来越快。
- 量化的选型判断力：GPTQ、SmoothQuant、AWQ 各自在解决什么问题，什么场景该用哪个。
- 一张可叠加的优化全景图：三条路径如何正交叠加，构成生产级推理系统。
1 为什么推理这么慢：Transformer 推理的计算解剖¶
1.1 Transformer 前向传播的 FLOPs 解剖¶
要优化推理，首先要精确知道计算花在了哪里。一个标准 Transformer 层的前向传播包含以下组件：[14]
Self-Attention 模块：
输入 X ∈ ℝ^(seq_len × d_model)
① QKV 投影（三次矩阵乘法）：
Q = X · W_Q, K = X · W_K, V = X · W_V
FLOPs = 3 × 2 × seq_len × d_model² = 6 · seq_len · d_model²
② 注意力分数计算（Q·K^T）：
S = Q · K^T / √d_head
FLOPs = 2 × n_heads × seq_len² × d_head = 2 · seq_len² · d_model
③ Softmax + 加权求和（S·V）：
O = softmax(S) · V
FLOPs = 2 × n_heads × seq_len² × d_head = 2 · seq_len² · d_model
④ 输出投影：
Y = O · W_O
FLOPs = 2 · seq_len · d_model²
FFN/MLP 模块（以 SwiGLU 为例，d_ff = 8/3 · d_model）：
⑤ Gate 投影 + Up 投影 + Down 投影（三次矩阵乘法）：
gate = X · W_gate FLOPs = 2 · seq_len · d_model · d_ff
up = X · W_up FLOPs = 2 · seq_len · d_model · d_ff
down = SiLU(gate) ⊙ up · W_down FLOPs = 2 · seq_len · d_ff · d_model
SwiGLU 总 FLOPs = 3 × 2 · seq_len · d_model · d_ff
= 6 · seq_len · d_model · (8/3 · d_model)
= 16 · seq_len · d_model²
单层总计：
Attention FLOPs = 8 · seq_len · d_model² + 4 · seq_len² · d_model
FFN FLOPs = 16 · seq_len · d_model²
LayerNorm ≈ 0（可忽略）
单层合计 = 24 · seq_len · d_model² + 4 · seq_len² · d_model
关键观察：
- FFN 占主导：在 seq_len 不太长时（< 数千），FFN 占前向传播约 66% 的 FLOPs
- 注意力的二次项：$4 \cdot seq_len^2 \cdot d_{model}$ 在长上下文时才成为瓶颈——seq_len > 6·d_model 时注意力超过 FFN
- 嵌入层和 LM Head 在大模型中占 <0.1%，可忽略
整个模型的 FLOPs（每 token）：
FLOPs_per_token ≈ 2 × n_params（近似法则）
推导：
每层参数 ≈ 12 · d_model²（QKV + O + 3 个 FFN 矩阵）
每层 FLOPs ≈ 24 · d_model²（对 seq_len=1 的 decode 步）
比值 = 24 / 12 = 2 FLOPs per parameter per token
真实模型的 FLOPs/token：
FLOPs/token 近似公式：$\approx 2 \times$ 激活参数量。对于 MoE 模型，每 token 只激活部分专家，因此 FLOPs 由激活参数量决定，而非总参数量。
Dense 模型（全参数激活）：
| 模型 | 总参数 | d_model | 层数 | 注意力头 / KV 头 | FLOPs/token |
|---|---|---|---|---|---|
| LLaMA-3 8B | 8B | 4096 | 32 | 32 / 8 (GQA-8) | ~16 GFLOPs |
| Gemma 3 27B | 27B | 5376 | 62 | 32 / 16 (GQA-2) | ~54 GFLOPs |
| Qwen2.5 72B | 72B | 8192 | 80 | 64 / 8 (GQA-8) | ~144 GFLOPs |
| LLaMA-3.1 405B | 405B | 16384 | 126 | 128 / 8 (GQA-8) | ~810 GFLOPs |
MoE 模型（仅部分专家激活）：
| 模型 | 总参数 | 激活参数 | d_model | 层数 | 专家数 / 激活数 | FLOPs/token | 备注 |
|---|---|---|---|---|---|---|---|
| LLaMA-4 Scout | 109B | 17B | 5120 | 48 | 16 / 1+1shared | ~34 GFLOPs | 全层 MoE，GQA 40/8 |
| LLaMA-4 Maverick | 400B | 17B | 5120 | 48 | 128 / 1+1shared | ~34 GFLOPs | MoE 与 Dense 层交替 |
| Qwen3 235B-A22B | 235B | 22B | 4096 | 94 | 128 / 8 | ~44 GFLOPs | GQA 64/4，无 shared expert |
| DeepSeek-V3/R1 | 671B | 37B | 7168 | 61 | 256 / 8+1shared | ~74 GFLOPs | MLA（d_c=512），前 3 层 Dense |
以 Qwen2.5 72B 为例手算验证：
每层参数 ≈ 8 · d_model² (QKV+O) + 3 · d_model · d_ff (SwiGLU FFN)
= 8 × 8192² + 3 × 8192 × 29568
= 537M + 726M ≈ 1.26B
80 层合计 ≈ 80 × 1.26B ≈ 100B（含 embedding 和 LM head 约 72B，因为有参数共享）
FLOPs/token ≈ 2 × 72B ≈ 144 GFLOPs ✓
核心观察：
- MoE 的效率杠杆：DeepSeek-V3 拥有 671B 参数但每 token 仅激活 37B（5.5%），FLOPs 与 Qwen2.5 72B 相当，但质量远超——这就是 MoE 的核心优势
- 同为 17B 激活：LLaMA-4 Scout（109B）和 Maverick（400B）的 FLOPs/token 相同，区别在于 Maverick 拥有更多专家带来更强的知识容量
- GQA 已成标配：2024 年后所有主流模型均使用 GQA（KV 头 ≤ 8），唯一例外是 DeepSeek 使用更激进的 MLA
1.2 Decode 阶段：为什么 GPU 99% 时间在等数据¶
Decode 阶段每步只处理 1 个 token（seq_len=1），此时注意力的二次项消失，计算量极小。但模型的全部权重仍然需要从显存加载一遍：[15]
以 LLaMA-2 70B (FP16) 为例：
搬运量：70B × 2 bytes = 140 GB（加载全部权重）
计算量：140 GFLOPs
A100 GPU：
显存带宽：2.0 TB/s → 搬运 140 GB 需要 70 ms
算力峰值：312 TFLOPs → 计算 140 GFLOPs 需要 0.45 ms
算术强度 = 140 GFLOPs / 140 GB = 1 FLOP/Byte
临界算术强度 = 312 TFLOPs / 2 TB/s = 156 FLOPs/Byte
1 << 156 → 极度 memory-bound
GPU 算力利用率 ≈ 1/156 ≈ 0.6%
H100 GPU：
显存带宽：3.35 TB/s → 搬运 140 GB 需要 42 ms
算力峰值：~990 TFLOPs (FP16 Tensor Core)
算术强度：仍为 1 FLOP/Byte
临界算术强度 = 990 / 3.35 = 295 FLOPs/Byte
GPU 算力利用率 ≈ 1/295 ≈ 0.3%
结论：在单请求 Decode 中，GPU 有 99%+ 的算力在空转，瓶颈完全在显存带宽。 这不是软件写得差——这是 Decode 阶段矩阵-向量乘法的本质特征。[15]
1.3 Prefill vs Decode：同一模型，两种瓶颈¶
有了 KV Cache（详见第 2 章），推理分为两个阶段，它们的计算特征截然不同：[15][16]
| 维度 | Prefill（预填充） | Decode（解码） |
|---|---|---|
| 输入 | 整个 prompt（数百~数千 token） | 单个 token |
| 核心操作 | 矩阵-矩阵乘法（GEMM） | 矩阵-向量乘法（GEMV） |
| 算术强度 | 55–100 FLOPs/Byte（高） | 0.5–2 FLOPs/Byte（极低） |
| 瓶颈 | 计算受限（Compute-Bound） | 访存受限（Memory-Bound） |
| GPU 利用率 | 60–85% | 10–20%（理论最低 <1%） |
| 注意力开销 | O(N²)，长序列时主导 | O(N)，线性但需加载全部 KV Cache |
| 优化方向 | 减少 FLOPs、提高并行度 | 减少数据搬运、压缩数据 |
1.4 GPU 内存层次：带宽鸿沟的根源¶
GPU 的内存层次结构有多级带宽差异，这是理解所有优化技术的硬件基础：[8][14]
┌────────────────────────────────────────────────────────────────┐
│ 寄存器文件（Register File） │
│ 容量：256 KB/SM 带宽：受限于计算流水线 延迟：0 周期 │
├────────────────────────────────────────────────────────────────┤
│ L1 / 共享内存（Shared Memory / SRAM） │
│ 容量：192–256 KB/SM 带宽：~19 TB/s/SM 延迟：~4 周期 │
│ 用途：FlashAttention 的 tiling 目标层 │
├────────────────────────────────────────────────────────────────┤
│ L2 缓存 │
│ 容量：40–50 MB（全 GPU 共享） 带宽：~5.5 TB/s 延迟：~30 周期│
│ 注意：Decode 时 KV Cache 访问模式破坏局部性，命中率仅 2–16% │
├────────────────────────────────────────────────────────────────┤
│ HBM（高带宽显存） │
│ 容量：40–192 GB 带宽：2–9 TB/s 延迟：~300 周期 │
│ 瓶颈所在：Decode 阶段的权重和 KV Cache 搬运 │
└────────────────────────────────────────────────────────────────┘
三代 GPU 的关键规格对比：
| 指标 | A100 (SXM) | H100 (SXM) | B200 |
|---|---|---|---|
| HBM 容量 | 80 GB | 80 GB | 192 GB |
| HBM 带宽 | 2.0 TB/s | 3.35 TB/s | 9.0 TB/s |
| FP16 Tensor Core 算力 | 312 TFLOPs | ~990 TFLOPs | ~2,250 TFLOPs |
| 临界算术强度 | 156 FLOPs/B | 295 FLOPs/B | 250 FLOPs/B |
| L2 缓存 | 40 MB | 50 MB | ~96 MB |
| SRAM/SM | 192 KB | 256 KB | 256 KB |
关键洞察： 从 A100 到 H100 到 B200，算力增长速度（~7×）远快于带宽增长速度（~4.5×），临界算术强度不断攀升。这意味着 Decode 阶段的 memory-bound 问题在新硬件上不仅没有缓解，反而更加严重——更多的算力在等更慢（相对而言）的数据搬运。
1.5 Roofline 模型：一张图定位所有瓶颈¶
Roofline 模型用一条折线定义了硬件的性能天花板，将操作的算术强度映射到可达性能：
可达性能 = min(峰值带宽 × 算术强度, 峰值算力)
H100 Roofline:
┌─────────────────────── 峰值算力：990 TFLOPs
│
性能 │ ╱──────────────────── 计算屋顶
(TFLOPS) │ ╱
│ ╱
│ ╱
│ FFN ╱ ← 带宽屋顶线（斜率 = 3.35 TB/s）
│ decode ╱
│ ↑ ╱
│ Attn ╱ FlashAttn Prefill
│ dec ╱ prefill ↑ GEMM ↑
│ ╱ ↑
│ ╱
└──────────────────────────────────────────
0.5 2 10 50 100 295 500
算术强度（FLOPs/Byte）
↑
临界算术强度 = 295
Transformer 各组件在 Roofline 上的位置：
| 组件 | Prefill 算术强度 | Decode 算术强度 | 瓶颈 |
|---|---|---|---|
| Attention QKV 投影 | ~55–100 | ~2 | Prefill: 计算 / Decode: 访存 |
| Attention Score (QK^T) | ~seq_len/2 | ~0.5 | 长序列 Prefill: 计算 / Decode: 访存 |
| FFN Up/Down 投影 | ~95 | ~2 | Prefill: 接近计算 / Decode: 访存 |
| KV Cache 加载 | — | ~0.5 | Decode: 极度访存受限 |
1.6 批处理如何改变瓶颈：临界 Batch Size¶
Batch 推理是解决 Decode 阶段 GPU 空转的最直接方法——多个请求共享同一份权重加载，将矩阵-向量乘法升级为矩阵-矩阵乘法：[14][15]
Batch=1: 算术强度 ≈ 1 FLOPs/Byte（搬 140GB 算 140GFLOPs）
Batch=B: 算术强度 ≈ B FLOPs/Byte（搬 140GB 算 B×140GFLOPs）
临界 Batch Size = 峰值算力 / 峰值带宽 / (FLOPs_per_param)
= 临界算术强度 / 2
| GPU | 临界算术强度 | 临界 Batch Size（理论） | 实际可达 |
|---|---|---|---|
| A100 | 156 | ~78 | 受限于 KV Cache 显存 |
| H100 | 295 | ~148 | 受限于 KV Cache 显存 |
| B200 | 250 | ~125 | 显存更大，实际可达更高 |
但实际中 Decode 即使在大 batch 下仍然 memory-bound：
- 增大 batch → 每个请求的 KV Cache 需要额外加载，数据搬运量也随 batch 线性增长
- L2 缓存命中率在 Decode 时仅 2–16%（KV Cache 的散乱访问模式破坏空间局部性）
- 实测：即使 batch=100 以上，GPU 利用率也通常只有 30–40%
这就是为什么仅靠批处理无法根本解决 Decode 阶段的效率问题，需要从算法（投机解码）、数据（量化）和计算（FlashAttention/FlashDecoding）三个维度同时优化。下面按照"Prefill → Decode → 模型体积"的顺序，逐一展开这三条路径。
2 注意力计算优化：FlashAttention 全系列¶
2.1 标准注意力的 IO 瓶颈分析¶
在 FlashAttention 之前，注意力优化的思路是减少 FLOPs——用稀疏注意力、线性注意力等近似方法降低 $O(N^2)$ 的计算量。但实测中，这些方法在墙钟时间上往往收效甚微。FlashAttention 的核心洞察是：注意力的瓶颈不是 FLOPs，而是 HBM 读写。 [8]
标准注意力的计算流程，每一步都要把中间结果写回 HBM：
标准流程（每步都读写 HBM）：
① Q, K 从 HBM 读取 → S = Q·K^T → S 写回 HBM
HBM 读取：2 × N × d bytes
HBM 写入：N² bytes
中间矩阵 S ∈ ℝ^(N×N)：N=128K 时约 32 GB（FP16）
② S 从 HBM 读取 → P = softmax(S) → P 写回 HBM
HBM 读取：N² bytes
HBM 写入：N² bytes
③ P, V 从 HBM 读取 → O = P·V → O 写回 HBM
HBM 读取：N² + N×d bytes
HBM 写入：N×d bytes
总 HBM 访问：Θ(Nd + N²)
总计算量： Θ(N²d)
当 d << N 时（长序列），IO 是 Θ(N²) 级别的——
但实际计算只有 Θ(N²d) ≈ Θ(N²·128)
IO/计算比 ≈ 1/d ≈ 1/128
→ 大量时间浪费在 N² 级的中间矩阵读写上
HBM 与 SRAM 的带宽差距是关键：
SRAM 带宽是 HBM 的 ~10× 以上（A100：19 TB/s vs 2 TB/s）。如果能把 N×N 中间矩阵的计算全部限制在 SRAM 中，就能消除最大的 IO 瓶颈。[8]
2.2 FlashAttention 的核心算法：Tiling + Online Softmax¶
论文： Dao et al., NeurIPS 2022 [8]
FlashAttention 的关键技术挑战是：softmax 需要全局归一化——$\text{softmax}(x_i) = e^{x_i} / \sum_j e^{x_j}$——这似乎要求先算出完整的 N×N 矩阵才能计算分母。
Online Softmax 通过增量方式解决了这个问题，其数学基础是：softmax 可以分块计算，然后通过 rescaling 合并：[8]
给定两个分块 [x₁, x₂, ..., xₖ] 和 [xₖ₊₁, ..., xₙ]，
它们的 softmax 可以通过以下方式合并：
设 m₁ = max(x₁:ₖ), m₂ = max(xₖ₊₁:ₙ)
设 ℓ₁ = Σᵢ₌₁ᵏ exp(xᵢ - m₁), ℓ₂ = Σᵢ₌ₖ₊₁ⁿ exp(xᵢ - m₂)
合并后的全局 softmax：
m = max(m₁, m₂)
ℓ = exp(m₁ - m) · ℓ₁ + exp(m₂ - m) · ℓ₂
softmax(xᵢ) = exp(xᵢ - m) / ℓ
完整的 FlashAttention Tiling 算法：
输入：Q, K, V ∈ ℝ^(N×d)，分块大小 Br × Bc
输出：O ∈ ℝ^(N×d)
将 Q 分为 Tr = ⌈N/Br⌉ 个行块，K/V 分为 Tc = ⌈N/Bc⌉ 个列块
对每个 Q 块 i（i = 1..Tr）：
初始化：mᵢ = -∞（行最大值向量），ℓᵢ = 0（行指数和），Oᵢ = 0
对每个 K/V 块 j（j = 1..Tc）：
1. 从 HBM 加载 Qᵢ ∈ ℝ^(Br×d), Kⱼ ∈ ℝ^(Bc×d), Vⱼ ∈ ℝ^(Bc×d) 到 SRAM
2. 在 SRAM 中计算：Sᵢⱼ = Qᵢ · Kⱼᵀ / √d ∈ ℝ^(Br×Bc)
3. 计算行最大值：m̃ᵢⱼ = rowmax(Sᵢⱼ)
4. 计算 softmax 分子：P̃ᵢⱼ = exp(Sᵢⱼ - m̃ᵢⱼ)
5. 计算行指数和：ℓ̃ᵢⱼ = rowsum(P̃ᵢⱼ)
6. 更新全局最大值：mᵢ_new = max(mᵢ, m̃ᵢⱼ)
7. Rescale 已有累积：
ℓᵢ_new = exp(mᵢ - mᵢ_new) · ℓᵢ + exp(m̃ᵢⱼ - mᵢ_new) · ℓ̃ᵢⱼ
Oᵢ_new = diag(exp(mᵢ - mᵢ_new)) · ℓᵢ · Oᵢ / ℓᵢ_new
+ exp(m̃ᵢⱼ - mᵢ_new) · P̃ᵢⱼ · Vⱼ / ℓᵢ_new
8. 更新：mᵢ = mᵢ_new, ℓᵢ = ℓᵢ_new, Oᵢ = Oᵢ_new
写回 Oᵢ 到 HBM
SRAM 使用量精确计算：
Qᵢ: Br × d × 2 bytes 典型值 128 × 128 × 2 = 32 KB
Kⱼ: Bc × d × 2 bytes = 32 KB
Vⱼ: Bc × d × 2 bytes = 32 KB
Sᵢⱼ: Br × Bc × 2 bytes = 32 KB
P̃ᵢⱼ: Br × Bc × 2 bytes = 32 KB
Oᵢ: Br × d × 2 bytes = 32 KB
mᵢ, ℓᵢ: Br × 2 × 2 bytes ≈ 1 KB
─────────────────────────────────────────────────
总计：约 193 KB（恰好装入 A100 的 192 KB SRAM）
2.3 IO 复杂度：从 Θ(N²) 到 O(N²d²/M)¶
定理（FlashAttention IO 复杂度）：
设 SRAM 大小为 $M$ 字节，序列长度 $N$，头维度 $d$。FlashAttention 的 HBM 访问次数为：
$$\Theta\left(\frac{N^2 d^2}{M}\right)$$
证明思路：
分块大小选取：Br = Bc = Θ(M/d)
→ 每个 Q/K/V 块大小 = Θ(M/d) × d = Θ(M) bytes（刚好装满 SRAM）
→ Q 的块数 Tr = N / Br = Θ(Nd/M)
→ K/V 的块数 Tc = N / Bc = Θ(Nd/M)
每次迭代加载一个 Q 块 + 一个 K/V 块：
IO = Θ(M) bytes per iteration
总迭代次数 = Tr × Tc = Θ(N²d²/M²)
总 IO = Θ(M) × Θ(N²d²/M²) = Θ(N²d²/M)
对比标准注意力：Θ(Nd + N²)
当 M = Θ(Nd) 时（d=128 时约 16KB，远小于实际 SRAM）：
FlashAttention IO = Θ(N²d²/(Nd)) = Θ(Nd)
→ 消除了 N² 级的中间矩阵 IO
下界证明（不可再优化）：
论文还证明了 $\Omega(N^2 d^2 M^{-1})$ 的下界——FlashAttention 的 IO 复杂度是渐进最优的。[8]
2.4 FlashAttention 的实际收益¶
| 任务 | 序列长度 | 加速 | 其他收益 |
|---|---|---|---|
| BERT-large 训练 | 512 | 15% | — |
| GPT-2 训练 | 1K | 3× | 困惑度提升 0.7 |
| Long-Range Arena | 1K–4K | 2.4× | — |
| Path-X 分类 | 16K | — | 61.4% 准确率（此前无模型超越随机水平） |
| Path-256 分类 | 64K | — | 63.1% 准确率（首次可训练） |
FlashAttention 不仅加速了已有任务，更打开了长上下文的大门——让 16K–64K 序列从"不可训练"变为"可训练"。HBM 访问减少高达 9×。[8]
2.5 FlashAttention-2：逼近 GEMM 的硬件效率¶
论文： Dao, 2023 [9]
FlashAttention 解决了 IO 瓶颈，但 GPU 利用率仍只有 25–40%。瓶颈从 IO 转移到了GPU 内核的并行度和工作划分。FlashAttention-2 做了三个关键改进：[9]
改进一：减少非 matmul FLOPs
FlashAttention 的 rescaling 操作（步骤 7 中的 diag(exp(...))）
虽然不是主要瓶颈，但在 Tensor Core 上这些非 matmul 操作
占据了宝贵的执行时间槽：
FlashAttention: 非 matmul FLOPs 占比 ≈ 50%
FlashAttention-2: 非 matmul FLOPs 占比 ≈ 25%（通过延迟 rescaling）
改进二：跨 thread block 并行化
FlashAttention: 只在 batch 和 head 维度并行
→ 当 batch × n_heads < SM 数量时，SM 空闲
FlashAttention-2: 额外在 序列长度 维度并行
→ 将 N 维度切分到不同 thread block
→ GPU occupancy 大幅提升
改进三：Warp 级工作重分配
FlashAttention: 4 个 warp 分别处理 Q/K/V 的不同部分
→ warp 间需要共享内存通信 → 同步开销
FlashAttention-2: 重新分配工作，减少 warp 间通信
→ 每个 warp 独立处理完整的 QKV 子块
→ 共享内存读写减少
性能对比：
FlashAttention FlashAttention-2 理论上限
理论 FLOPs 利用率 25–40% 50–73% ~80%（GEMM）
训练吞吐 (TFLOPs/s) ~110 225 ~250
相对加速 1× 2× —
2.6 FlashAttention-3：Hopper 架构深度适配¶
FlashAttention-3（2024）针对 H100 的 Hopper 架构做了硬件级适配，利用了三个 Hopper 独有特性：
① Warp-specialization（warp 特化）
传统 GPU 编程：所有 warp 做同样的事情（SIMT 模型）
Hopper TMA（Tensor Memory Accelerator）：独立的数据搬运引擎
FlashAttention-3：
Producer warp: 专责通过 TMA 从 HBM 搬运数据到 SRAM
Consumer warp: 专责在 Tensor Core 上做矩阵乘法
→ 搬运和计算完全重叠（overlap），而非串行等待
② Block-wise Interleaving（块级交错）
标准流程： [Matmul₁] → [Softmax₁] → [Matmul₂] → [Softmax₂] → ...
FA-3 流程： [Matmul₁ | Softmax₀] → [Matmul₂ | Softmax₁] → ...
（matmul 和 softmax 交错执行，流水线始终满载）
③ FP8 支持
FA-3 FP8 策略：块量化 + incoherent processing
→ 数值误差比标准 per-tensor FP8 量化降低 2.6×
→ 在 H100 上达到 1.3 PFLOPs/s（FP8 Tensor Core 峰值的 ~75%）
FlashAttention-3 性能（H100）：
| 精度 | 吞吐 | GPU 利用率 | vs FA-2 |
|---|---|---|---|
| BF16 | 840 TFLOPs/s | 85% | 2× |
| FP8 | 1.3 PFLOPs/s | ~75% | — |
2.7 FlashDecoding：Decode 阶段的注意力并行化¶
FlashAttention 主要优化 Prefill 阶段。Decode 阶段有一个独特问题：Q 只有 1 个 token，但 KV 有整个序列——并行度极低。
标准 Decode Attention：
Q ∈ ℝ^(1×d), K ∈ ℝ^(N×d), V ∈ ℝ^(N×d)
计算 S = Q · K^T ∈ ℝ^(1×N) → 一个向量-矩阵乘法
计算 O = softmax(S) · V ∈ ℝ^(1×d)
问题：只有 1 个 Q token，只能分配给 1 个 thread block
→ 大量 SM 空闲
FlashDecoding 的解决方案：在 KV 序列维度上并行
将 K, V 切分为 P 个分片（P = 线程块数）：
K₁, K₂, ..., Kₚ（每片 N/P 个 token）
V₁, V₂, ..., Vₚ
Phase 1（并行）：每个 thread block 独立计算局部 attention：
Oⱼ = softmax(Q · Kⱼᵀ) · Vⱼ （局部结果）
mⱼ = max(Q · Kⱼᵀ) （局部最大值）
ℓⱼ = sum(exp(Q · Kⱼᵀ - mⱼ)) （局部指数和）
Phase 2（合并）：用 Online Softmax 的合并公式汇总：
m = max(m₁, ..., mₚ)
ℓ = Σⱼ exp(mⱼ - m) · ℓⱼ
O = Σⱼ exp(mⱼ - m) · ℓⱼ · Oⱼ / ℓ
FlashDecoding 性能：
- 长序列场景加速高达 8×
- FlashDecoding++ 进一步优化：异步 softmax + 双缓冲，7B/70B 模型吞吐额外提升 1.11–1.14×
2.8 FlashAttention 对推理格局的系统性影响¶
FlashAttention 系列的影响远超算法本身：
- 上下文窗口扩展：GPT-3 的 2K → GPT-4 的 128K → LLaMA 3 的 1M，FlashAttention 是关键使能技术
- 内存效率：O(N) 内存（vs 标准 O(N²)）使更大 batch 成为可能
- 生产标配：vLLM、SGLang、TensorRT-LLM 等所有主流推理引擎的基础组件
- 硬件协同演进：FA-2 → A100，FA-3 → H100，FA-4（开发中）→ Blackwell
FlashAttention 解决了注意力计算中的 IO 浪费，但 Decode 阶段的根本矛盾——每个 token 都要独立调用一次大模型——仍然没有解决。这就是投机解码要解决的问题。
3 投机解码：用猜测换速度¶
3.1 核心思想与直觉¶
Decode 阶段慢的根本原因是每个 token 都要独立调用大模型一次，而每次调用的计算量很小、搬运量很大。投机解码的核心思想是：用一个极快的小模型（草稿模型）先"猜"一串 token，再用大模型一次性"验"——把 γ 次串行的大模型调用合并为 1 次。[2][3]
传统自回归解码（每 token 1 次大模型前向）：
Step 1: p("The") → "The" ← 1 次大模型调用
Step 2: p("cat") → "cat" ← 1 次大模型调用
Step 3: p("sat") → "sat" ← 1 次大模型调用
Step 4: p("on") → "on" ← 1 次大模型调用
Step 5: p("the") → "the" ← 1 次大模型调用
→ 5 个 token 需要 5 次大模型前向
投机解码（γ 次小模型 + 1 次大模型验证）：
Draft: q("The cat sat on the") ← γ=5 次小模型前向（极快）
Verify: p("The cat sat on the") ← 1 次大模型前向
Accept: 验证通过 4 个 token ← 实际只花了 1 次大模型调用
→ 4 个 token 只需 1 次大模型前向 + γ 次小模型前向
关键约束：输出分布必须与直接用大模型生成完全一致——这不是近似加速，是精确加速。 [2]
3.2 拒绝采样的完整数学推导¶
投机解码的数学保证来自改造的拒绝采样。以下是完整推导：[2]
算法（逐 token）：
对草稿模型在位置 i 生成的 token x̃ᵢ：
接受概率：α(x̃ᵢ) = min(1, p(x̃ᵢ|context) / q(x̃ᵢ|context))
其中 p = 目标模型分布，q = 草稿模型分布
若 random() < α(x̃ᵢ)：
接受 x̃ᵢ，继续验证下一个
否则：
拒绝 x̃ᵢ，从修正分布重采样：
x_new ~ p'(x) = max(0, p(x) - q(x)) / Z
其中 Z = Σₓ max(0, p(x) - q(x))
正确性证明：
需要证明：P(output = x) = p(x)（即最终分布等于目标分布）
分两种情况：
情况 1：x̃ 被接受
P(x̃ = x ∧ accepted) = q(x) · min(1, p(x)/q(x)) = min(q(x), p(x))
情况 2：x̃ 被拒绝，从 p' 重采样
拒绝概率 β = Σₓ q(x) · max(0, 1 - p(x)/q(x))
= Σₓ max(0, q(x) - p(x))
P(resample = x) = β · p'(x)
= β · max(0, p(x) - q(x)) / Z
关键等式：β = Z（因为 Σ max(0, q(x)-p(x)) = Σ max(0, p(x)-q(x))）
→ P(resample = x) = max(0, p(x) - q(x))
合并两种情况：
P(output = x) = min(q(x), p(x)) + max(0, p(x) - q(x))
= p(x) ✓（当 p(x) ≥ q(x) 时两项分别为 q(x) 和 p(x)-q(x)）
✓（当 p(x) < q(x) 时两项分别为 p(x) 和 0）
这意味着无论草稿模型有多差，最终输出都严格等价于直接从目标模型采样。 草稿模型的质量只影响速度（接受率），不影响生成质量。
3.3 加速比的理论分析¶
期望接受长度：
设逐 token 接受率为 $\alpha$（假设独立），草稿长度为 $\gamma$：
E[接受 token 数] = Σⱼ₌₁ᵞ j · αʲ⁻¹(1-α) + (γ+1) · αᵞ
第 j 位被拒绝（前 j-1 个接受 + 1 个重采样）的概率：αʲ⁻¹(1-α)
全部接受（γ 个 + 1 个 bonus）的概率：αᵞ
化简（等比级数）：
τ = (1 - α^(γ+1)) / (1 - α)
期望加速比：
设 c = T_draft / T_target（草稿模型与目标模型的时延比）
每轮耗时 = γ · c · T_target + T_target = T_target · (γc + 1)
每轮产出 = τ 个 token
加速比 S = τ / (γc + 1) = (1 - α^(γ+1)) / [(1 - α)(γc + 1)]
理论上界（c → 0 时）：S_max = 1 / (1 - α)
α = 0.8 → S_max = 5×
α = 0.9 → S_max = 10×
投机解码何时反而更慢（S < 1）：
S < 1 的条件：τ < γc + 1
典型失败场景：
1. 接受率太低（α < 0.3）：τ ≈ 1.4，但 γc + 1 > 1.4
2. 草稿模型太贵（c > 0.5）：即使 α=0.8，加速被草稿开销抵消
3. 大 batch 推理：GPU 已计算饱和，额外草稿增加的是计算而非只是带宽
- Batch 1-4：典型 2-3× 加速
- Batch 8：仅 1.3-1.6× 加速
- Batch 32+：加速消失或负加速
3.4 接受率与分布距离的精确关系¶
接受率 $\alpha$ 与目标/草稿分布的 Total Variation Distance（TVD）有精确关系：
期望接受率 = 1 - TVD(p, q)
其中 TVD(p, q) = (1/2) · Σₓ |p(x) - q(x)|
推导：
E[α] = Σₓ q(x) · min(1, p(x)/q(x))
= Σₓ min(q(x), p(x))
= 1 - (1/2) Σₓ |p(x) - q(x)| （因为 Σ min = 1 - (1/2)Σ|差|）
= 1 - TVD(p, q)
实际影响因素：
| 因素 | 对接受率的影响 |
|---|---|
| 草稿模型质量差 | TVD 大 → α 低 |
| 高温度采样（τ > 1） | 分布更平坦 → TVD 通常增大 → α 下降 |
| Token 位置靠后 | 误差累积 → α 逐位下降：α(i) ≈ α_base · (1 - δ·log(i))，δ≈0.05-0.10 |
| 领域不匹配 | 草稿在目标领域准确率低 → TVD 大 → α 低 |
| KL 散度训练 vs TVD 直接优化 | TVD 直接优化比 KL 训练高 5–15% 接受率 |
3.5 完整算法伪代码¶
算法：Speculative Decoding（投机解码）
输入：目标模型 p, 草稿模型 q, 输入序列 s, 投机长度 γ
WHILE 未结束生成 DO：
── DRAFT PHASE ──
FOR i = 1 TO γ:
x̃ᵢ ~ q(·|s ⊕ x̃₁:ᵢ₋₁) # 草稿模型自回归生成
存储 q(x̃ᵢ|context) # 缓存草稿概率
── VERIFICATION PHASE ──
# 目标模型一次前向，并行计算所有位置的概率
p(·|s), p(·|s⊕x̃₁), ..., p(·|s⊕x̃₁:ᵧ) = Target_Forward(s, x̃₁:ᵧ)
── ACCEPTANCE PHASE ──
n_accepted = 0
FOR i = 1 TO γ:
αᵢ = min(1, p(x̃ᵢ|contextᵢ) / q(x̃ᵢ|contextᵢ))
IF random() < αᵢ THEN
接受 x̃ᵢ
n_accepted += 1
ELSE
# 从修正分布重采样
x_new ~ normalize(max(0, p(·|contextᵢ) - q(·|contextᵢ)))
s = s ⊕ x̃₁:ᵢ₋₁ ⊕ x_new
BREAK
IF n_accepted == γ THEN
# 全部接受，bonus token
x_bonus ~ p(·|s ⊕ x̃₁:ᵧ)
s = s ⊕ x̃₁:ᵧ ⊕ x_bonus
RETURN s
3.6 投机解码的演进路线¶
投机解码演进（2022–2025）
│
├── 草稿来源：谁来猜？
│ ├── 独立小模型 ← SpecDec [3] (2022), Speculative Sampling [2] (2023)
│ ├── 在线更新的小模型 ← Online Speculative Decoding [4] (2023)
│ ├── 多解码头（嵌入主模型） ← Medusa [7] (2024)
│ ├── 特征预测网络 ← EAGLE-1 (2024), EAGLE-2 (2024)
│ ├── token 预测 + 多层融合 ← EAGLE-3 [1] (2025)
│ └── 并行 drafter ← ParallelSpec [6] (2024), P-EAGLE (2025)
│
├── 草稿策略：怎么组织猜测？
│ ├── 自回归串行 ← 经典方案（最简单）
│ ├── 树形结构 ← Staged Spec [5] (2023), Medusa, EAGLE-2
│ └── 并行一次性生成 ← ParallelSpec, P-EAGLE
│
└── 验证策略：怎么高效验证？
├── 逐 token 拒绝采样 ← 经典方案
├── 树状注意力批量验证 ← Medusa, EAGLE
└── 稀疏 KV 验证 ← MagicDec [49] (2025)
3.7 SpecDec 与 Speculative Sampling：奠基之作¶
SpecDec（2022）[3] 是第一篇系统化研究投机解码的论文。在 seq2seq 任务（机器翻译、摘要）上，使用独立 drafter 实现约 5× speedup，打破了当时"投机解码只能加速 1.4×–2×"的认知。但方法局限于 seq2seq 任务，未扩展到通用生成。[3]
Speculative Sampling（2023，DeepMind）[2] 是投机解码走向通用的关键论文。它给出了 3.2 节中拒绝采样保证分布一致性的完整数学框架，并在 Chinchilla 70B 上验证了 2–2.5× 解码加速。核心贡献是建立了"草稿质量 → 接受率 → 加速比"的工程评估范式。[2]
3.8 Medusa：把草稿模型内嵌进主模型¶
论文： Cai et al., 2024 [7]
独立草稿模型的部署和维护成本高。Medusa 的方案是：在主模型上添加多个并行 MLP 解码头，每个头独立预测未来第 $k$ 个位置的 token：[7]
主模型最后一层的隐状态 h ∈ ℝ^d
│
├── LM Head（原始） → p(xₜ) 位置 t 的 token
├── Medusa Head 1 → p(xₜ₊₁) 位置 t+1 的 token
├── Medusa Head 2 → p(xₜ₊₂) 位置 t+2 的 token
├── Medusa Head 3 → p(xₜ₊₃) 位置 t+3 的 token
└── Medusa Head 4 → p(xₜ₊₄) 位置 t+4 的 token
每个 Medusa Head 结构：
Head_k(h) = W₂ · SiLU(W₁ · h) （两层 MLP）
树状验证： 5 个头各取 top-k₁..k₅ 预测，形成候选树（笛卡尔积），一次前向通过树状注意力掩码验证所有分支：
树状注意力掩码构造：
对于树中节点 i（路径为 root → n₁ → ... → nᵢ）：
A[i][j] = 1 当且仅当 节点 j 是节点 i 的祖先或同一节点
= 0 否则
这保证每个 token 只关注其在同一分支中的前驱，
不同分支之间相互隔离。
实际实现中将树展平为 1D 序列，
通过自定义 attention mask 实现树结构的因果约束。
训练策略：
- Medusa-1：冻结主干网络，只训练 Medusa 头。质量无损，speedup >2.2×
- Medusa-2：联合微调主干和 Medusa 头。speedup 2.3–3.6×
Medusa 的核心局限： 所有 Medusa 头的输入都是同一个隐状态 $h$，不包含采样历史。同一个 $h$ 可能对应不同的目标 token（取决于之前采样了什么 token），导致训练信号模糊。EAGLE 系列正是为解决这个问题而生。[7]
3.9 EAGLE 系列：三代架构演进¶
EAGLE 系列是截至 2025 年性能最强的投机解码方案，经历了三代架构革新：
EAGLE-1（ICML 2024）——特征空间自回归
核心思想：不在 token 空间做草稿预测，在特征空间做
架构：
输入 = [目标模型 L-2 层的特征 fₜ] ⊕ [采样 token 的 embedding e(x̃ₜ₊₁)]
↓ 拼接后通过 FC 层降维
X = FC([fₜ || e(x̃ₜ₊₁)]) ∈ ℝ^d
↓ 通过 Decoder 层（自回归）
f̂ₜ₊₁ = Decoder(X₁:ₜ)
↓ 使用目标模型的冻结 LM Head 映射为 token
p̂(xₜ₊₂) = Softmax(LM_Head(f̂ₜ₊₁))
关键创新——加入采样 token embedding：
e(x̃ₜ₊₁) 告诉草稿模型"之前实际采样了什么 token"
→ 解决了 Medusa 的训练信号模糊问题
→ 每个输入有唯一确定的目标输出
训练损失：L = L_reg + 0.1 · L_cls
L_reg = SmoothL1(f̂, f_actual) # 特征回归
L_cls = CrossEntropy(p̂, p_actual) # token 分类
EAGLE-2（EMNLP 2024）——上下文感知动态草稿树
EAGLE-1 的局限：固定的投机深度，不同样本的最优深度不同
EAGLE-2 的解决方案：用草稿模型的置信度分数动态调整树结构
动态树扩展算法：
1. 初始草稿：x̃₁..x̃ᵧ ~ draft_model(prompt)
2. 计算路径置信度：
value[节点 n] = Π(置信度 along path from root to n)
3. 选择 top-2 高置信度节点扩展子节点
4. 重排所有节点，选择 top-m 展平为 1D 序列
5. 单次目标模型前向验证
性能：3.05–4.26× speedup（vs EAGLE-1 提升 20–40%）
EAGLE-3（NeurIPS 2025）[1] ——直接 token 预测 + Scaling Law
EAGLE-3 做了两个重大架构变化和一个训练创新：
架构变化 1：放弃特征预测，直接预测 token
EAGLE-1/2 损失：L = L_feature_regression + L_token_cls
EAGLE-3 损失： L = L_token_only（仅 token 分类损失）
原因：特征回归是一个中间目标，限制了模型的表达能力
效果：草稿模型的容量被完全释放用于 token 预测
架构变化 2：多层特征融合
EAGLE-1/2：只使用目标模型顶层（L-2）的特征
EAGLE-3：融合低/中/高三层特征
以 Llama-3.1-8B（32 层，d=4096）为例：
f^low = Layer 3 输出 ∈ ℝ^(bs × seq × 4096) # 句法结构
f^mid = Layer 16 输出 ∈ ℝ^(bs × seq × 4096) # 语义块
f^high = Layer 30 输出 ∈ ℝ^(bs × seq × 4096) # 最终语义
f_fused = FC([f^low || f^mid || f^high])
= FC(∈ ℝ^(bs × seq × 12288)) → ℝ^(bs × seq × 4096)
训练创新——Training-Time Test（TTT）：
传统训练：草稿模型输入 = 真实 token（ground truth）
→ 推理时输入 = 自己的预测 → 分布不匹配（exposure bias）
TTT：训练时模拟多步自回归生成
Step 1: f̂₁ = Draft(features)
Step 2: x̂₁ = sample(f̂₁) # 用自己的预测
Step 3: f̂₂ = Draft(features, x̂₁) # 再用自己的预测作为输入
Step 4: ...
效果：草稿模型学会处理自己的预测输出，消除 train-test 不匹配
EAGLE-3 的突破性发现——投机解码的 Scaling Law：
EAGLE-1/2：增加训练数据 → 特征回归损失下降 → 但 speedup 几乎不变
原因：特征回归是硬约束，数据无法突破这个瓶颈
EAGLE-3：增加训练数据 → speedup 持续提升
实测数据（近似）：
1× ShareGPT 数据 → ~3.0× speedup
2× ShareGPT 数据 → ~3.5× speedup
4× ShareGPT 数据 → ~4.5× speedup
8× ShareGPT 数据 → ~6.0× speedup
经验公式：speedup ≈ 3.0 + 0.8 · log₂(data_scale)
这是首个展示 "训练规模 → 推理加速" 持续转化的投机解码方案。
EAGLE-3 性能总结：
| 指标 | 数据 |
|---|---|
| 最大 speedup | 6.5×（vs 标准自回归） |
| vs EAGLE-2 | 延迟降低 ~1.4× |
| SGLang batch=64 | 吞吐提升 1.38× |
| 任务覆盖 | 聊天、推理、代码等 5 个任务 |
3.10 其他重要变体¶
Online Speculative Decoding（2023）[4]
解决草稿模型与真实请求分布不匹配的问题。通过在线蒸馏持续更新草稿模型，使其适配当前用户请求分布。接受率提升 0.1–0.65，时延降低 1.42×–2.17×。[4]
Staged Speculative Decoding（2023）[5]
针对小 batch / 端侧推理。树形草稿批次 + 两阶段验证，在 GPT-2-L (762M) 上实现 3.16× 延迟降低。[5]
ParallelSpec（2024）[6]
将草稿生成从自回归改为并行：一次前向预测多个未来 token。时延最高降低 62%，Llama-2-13B 上 2.84× speedup。[6]
3.11 2025 前沿：投机解码的新方向¶
Mirror Speculative Decoding（Apple, 2025）
打破延迟-接受率权衡。双向投机——草稿模型与目标模型在异构设备（GPU + NPU）上并行运行。墙钟加速 2.8–5.8×，相比 EAGLE-3 平均提升 30%。
P-EAGLE（AWS/vLLM, 2025）
解决批量推理中的 ragged tensor 问题：不同序列接受的草稿 token 数不同，导致张量形状不齐、position ID 错位、KV Cache 指针损坏。
Ragged Tensor 问题具体示例：
Batch 中 2 个序列：
Seq 1: 草稿 5 tokens, 接受 [✓,✓,✓,✓,✓] → 前进 5 步
Seq 2: 草稿 5 tokens, 接受 [✓,✓,✗,X,X] → 前进 2 步
下一步的输入长度不同 → 无法简单 batch
Position ID 错位 → 注意力掩码出错
KV Cache 状态不一致 → 需要精确管理每个 slot
P-EAGLE 解决方案：
1. 并行草稿：单次前向生成所有 K 个草稿 token（非自回归）
2. Slot-based KV Cache：每个序列独立 slot 映射
3. 融合内核：position ID + attention mask + KV slot 在单个内核中处理
性能：相比 EAGLE-3 额外加速 1.69×（B200），已集成到 vLLM v0.16.0+。
3.12 投机解码全景对比¶
| 方案 | 年份 | 草稿来源 | 草稿策略 | 典型 Speedup | 最佳场景 |
|---|---|---|---|---|---|
| SpecDec [3] | 2022 | 独立模型 | 自回归 | ~5× | seq2seq 任务 |
| Speculative Sampling [2] | 2023 | 独立模型 | 自回归 | 2–2.5× | 通用生成 |
| Online Spec [4] | 2023 | 在线更新 | 自回归 | 1.42–2.17× | 长期在线服务 |
| Staged Spec [5] | 2023 | 独立模型 | 树形 | 3.16× | 端侧/小 batch |
| Medusa [7] | 2024 | 多解码头 | 并行 + 树验证 | 2.3–3.6× | 单模型部署 |
| ParallelSpec [6] | 2024 | 并行 drafter | 并行 | 2.84× | 低延迟 |
| EAGLE-2 | 2024 | 特征预测 | 动态树 | 3.05–4.26× | 通用 |
| EAGLE-3 [1] | 2025 | token 预测 | 动态树 | 最高 6.5× | 通用 |
| Mirror SD | 2025 | 双向异构 | 并行 | 2.8–5.8× | 异构硬件 |
| P-EAGLE | 2025 | 并行 EAGLE | 并行 | EAGLE-3 × 1.69 | batch 推理 |
生产部署实绩：
- Google AI Overviews：投机解码实现 2–3× 加速，减少等量请求所需的机器数
- Meta Llama：8B/13B 模型 2× 加速，代码模型 3× 加速
- 框架支持：vLLM、SGLang、TensorRT-LLM 均已原生支持
投机解码解决了"每 token 一次大模型调用"的问题，但还有一个更基础的矛盾没有触及：模型本身太大了。70B 模型 FP16 要 140 GB 显存，单卡根本装不下。即使装得下，每个 token 搬运 140 GB 的带宽代价也巨大。量化就是从根源上压缩这个数字。
4 量化压缩：让大模型装进小显卡¶
4.1 均匀量化的数学基础¶
量化将高精度浮点数映射到低精度整数，其本质是一个离散化过程。
对称量化（Symmetric）：
量化： x_q = clip(round(x / s), Q_min, Q_max)
反量化：x̂ = x_q · s
其中：
s = 2 · max(|x|) / (2^b - 1) # 缩放因子
Q_min = -(2^(b-1) - 1) # 如 INT8: -127
Q_max = 2^(b-1) - 1 # 如 INT8: 127
零点固定为 0
非对称量化（Asymmetric/Affine）：
量化： x_q = clip(round(x / s + z), Q_min, Q_max)
反量化：x̂ = (x_q - z) · s
其中：
s = (x_max - x_min) / (2^b - 1) # 缩放因子
z = round(-x_min / s) # 零点偏移
Q_min = 0, Q_max = 2^b - 1 # 如 UINT8: 0-255
量化误差分析：
每个量化区间的宽度 Δ = s（缩放因子）
在均匀分布假设下，量化误差的方差：
σ²_q = Δ² / 12 = s² / 12
总均方误差（MSE）= 截断误差 + 量化误差：
MSE = ∫_{-∞}^{x_min} x² p(x)dx + ∫_{x_max}^{∞} x² p(x)dx + s²/12
↑ 超出量化范围的值被截断 ↑ 范围内的离散化误差
量化粒度：
| 粒度 | 共享同一 (s, z) 的范围 | 精度 | 元数据开销 |
|---|---|---|---|
| Per-tensor | 整个权重矩阵 | 最低 | 最小（1 组 s,z） |
| Per-channel | 每个输出通道 | 中等 | C 组 s,z |
| Per-group | 每 32–128 个元素 | 最高 | N/G 组 s,z |
Per-group（典型 group_size=128）是 4-bit 量化的默认选择——它在精度和开销之间取得最佳平衡。每组额外存储 0.15 bits/元素的元数据（缩放因子）。
4.2 GPTQ：二阶 Hessian 补偿的逐层量化¶
论文： Frantar et al., 2022 [11]
GPTQ 的核心问题：如何在不重新训练的前提下，将 175B 模型量化到 3–4 bit？传统逐权重量化的误差会迅速累积。GPTQ 利用二阶信息（Hessian 矩阵）指导量化顺序和误差补偿。[11]
数学框架——层级量化目标：
对权重矩阵 W ∈ ℝ^(d_out × d_in)，校准数据激活 X ∈ ℝ^(n × d_in)：
目标：min_Q ||WX - Q(W)X||²_F
= min_Q Σⱼ (Wⱼ - Q(Wⱼ))ᵀ H (Wⱼ - Q(Wⱼ))
其中 H = 2X^T X + λI 为 Hessian 矩阵（带正则化）
GPTQ 的逐列量化 + 误差补偿：
核心思想：量化第 i 列后，用 Hessian 逆矩阵指导调整未量化列
量化第 i 列时：
1. 量化：W_q[i] = quantize(W[i])
2. 误差：eᵢ = W[i] - W_q[i]
3. 补偿（关键步骤）：
对所有未量化列 j > i：
W[j] := W[j] - (eᵢ / H⁻¹[i,i]) · H⁻¹[i, j]
直觉：H⁻¹[i,j] / H⁻¹[i,i] 告诉我们
"第 i 列的量化误差应该分摊多少给第 j 列"
—— 分摊比例由权重对输出的二阶影响决定
分块优化（Blocking Trick）：
逐列量化需要 O(d²) 的 Hessian 逆更新，太慢。
GPTQ 将列分为大小 B=128 的块：
FOR 每个块 [i, i+B)：
1. 块内逐列量化 + 补偿（O(B²) per block）
2. 块完成后，一次性更新剩余所有列（lazy batch update）
复杂度从 O(d³) 降至 O(d²·B)
使用 Cholesky 分解加速 Hessian 逆：
H⁻¹ 的 Cholesky 分解：H⁻¹ = L L^T
→ 量化补偿中的 H⁻¹[i,j] / H⁻¹[i,i] 可以直接从 L 读取
→ 数值稳定性更好
→ 不需要显式存储完整的 H⁻¹
GPTQ 关键结果： [11]
| 指标 | 数据 |
|---|---|
| 量化精度 | 3–4 bit（per-group, group_size=128） |
| 175B 模型量化耗时 | ~4 GPU 小时 |
| A100 推理加速 | 3.25× |
| A6000 推理加速 | 4.5× |
| 历史意义 | 175B 模型首次单 GPU 推理 |
| 精度损失 | WikiText 困惑度变化 0.1–0.3 |
4.3 SmoothQuant：激活平滑的等价变换¶
论文： Xiao et al., 2022 [12]
权重量化相对容易，因为权重分布较均匀。激活量化面临独特挑战：LLM 的激活中存在显著的异常值（outlier），某些通道的值比典型通道大 5–15 倍：[12]
激活异常值的影响：
通道值分布（某层示例）：
通道 1-511：值在 [-0.5, 0.5] 范围
通道 512： 值在 [-8.0, 8.0] 范围 ← 异常值通道
Per-tensor INT8 量化时：
s = 2 × 8.0 / 127 = 0.126
通道 1-511 的有效量化级数 = 0.5 / 0.126 ≈ 4 级（精度极差）
通道 512 的有效量化级数 = 8.0 / 0.126 = 63 级（正常）
→ 异常值通道"浪费"了大部分量化范围
→ 正常通道的精度严重不足
SmoothQuant 的核心思想——等价变换： [12]
原始计算：Y = X · W
SmoothQuant 变换：
Y = (X · diag(s)⁻¹) · (diag(s) · W)
= X̂ · Ŵ
关键：diag(s)⁻¹ · diag(s) = I → 变换后计算结果完全不变
效果：
X̂ = X · diag(s)⁻¹ → 激活被"平滑"，异常值缩小
Ŵ = diag(s) · W → 权重吸收异常值，分布稍变宽但仍可控
等价性证明：
X̂ · Ŵ = (X · diag(s)⁻¹) · (diag(s) · W)
= X · (diag(s)⁻¹ · diag(s)) · W
= X · I · W
= X · W = Y ✓
缩放因子的选取：
sⱼ = max(|Xⱼ|)^α / max(|Wⱼ|)^(1-α)
其中：
j = 通道索引（逐通道平滑）
Xⱼ = 校准数据中第 j 个通道的激活值
Wⱼ = 第 j 列的权重值
α ∈ [0, 1] = 迁移强度超参
α 的含义：
α = 0：完全不平滑（sⱼ 与激活无关）
α = 0.5：平衡迁移（默认值，适用于 OPT、BLOOM）
α = 0.75：强迁移（适用于异常值极端的模型如 GLM-130B）
α = 1：完全迁移（sⱼ 完全由激活决定）
直觉：
异常值通道的 max(|Xⱼ|) 大 → sⱼ 大 → X̂ⱼ = Xⱼ/sⱼ 缩小
→ 异常值被"平滑"掉
→ 对应的 Ŵⱼ = sⱼ · Wⱼ 变大，但权重分布本来就均匀，
变大一点不影响量化
SmoothQuant 关键结果： [12]
| 指标 | 数据 |
|---|---|
| 量化方案 | W8A8（权重和激活均 INT8） |
| 推理加速 | 最高 1.56× |
| 内存节省 | 2× |
| 最大支持 | 530B 模型单节点部署 |
| 适用模型 | OPT、BLOOM、GLM-130B 等多模型族 |
| 核心优势 | 全矩阵 INT8 → 可使用硬件 INT8 Tensor Core |
4.4 AWQ：保护 1% 的显著权重¶
论文： Lin et al. (MIT), 2023
AWQ 发现了一个关键现象：只有约 1% 的权重是"显著权重"（salient weights）——它们对应激活中大幅值通道。量化这些权重时的误差被激活放大，对输出影响巨大。
量化误差的输出影响：
Err(Q(W) · X) = Δ · RoundErr(W/Δ) · X
误差与激活幅值成正比！
大激活 × 大量化误差 → 输出严重偏差
AWQ 的核心策略：
1. 识别显著权重：
importance_j = mean_over_calibration(|X_j|)
选择 top-1% 的通道
2. 保护显著权重（缩放变换）：
W' = W · diag(s)⁻¹ # 显著通道的权重被放大
X' = X · diag(s) # 对应激活被缩小（等价变换）
3. 缩放因子搜索：
s_j = mean(|X_j|)^α*
α* = argmin_α∈[0,1] L(s^α) # 网格搜索最优 α
4. 量化 W'：
显著权重被放大 → 相对量化误差更小
整体质量保留率从 ~90% 提升到 ~95%
为什么 1% 权重如此重要（定量分析）：
层输出的量化损失分解：
ΔL ∝ Σⱼ σ²_q(j) · importance²(j)
Top-1% 通道的 importance²(j) 贡献了总损失的 ~50%
保护这 1% → 总损失下降 25–40%
→ 质量保留从 90% 提升到 95%（per-group INT4）
4.5 GPTQ vs AWQ vs GGUF：量化方案选型¶
| 维度 | GPTQ | AWQ | GGUF |
|---|---|---|---|
| 数学方法 | Hessian 二阶补偿 | 激活感知缩放 | 混合精度分块 |
| 量化精度 | 3–4 bit | 4 bit | 混合（Q4_K_M 等） |
| 目标硬件 | CUDA GPU | CUDA GPU（最优） | CPU + Apple Silicon |
| 质量保留 | ~90% | ~95% | ~92% |
| 量化速度 | 较慢（需 Hessian） | 快（无反传） | 快 |
| 最佳吞吐 | 快 | 最快（741 tok/s, Marlin） | 均衡 |
| 生态成熟度 | 最高（HuggingFace 原生） | 高（vLLM 优化） | 高（llama.cpp 原生） |
GGUF 的独特定位：
GGUF 是 llama.cpp 的原生格式，走了完全不同的路——针对 CPU 和 Apple Silicon 的统一内存架构优化。Apple M-series 的统一内存消除了 PCIe 瓶颈，使 CPU 推理在消费级硬件上可行。支持将部分层卸载到 GPU，实现灵活的混合推理。
4.6 混合精度量化：哪些层更敏感¶
不是所有层对量化的敏感度相同。基于 Hessian 迹的敏感度分析发现：[11][12]
敏感度排序（从高到低）：
最敏感：Attention 输出投影（W_O） → 建议保持 8-bit
中等： Attention QKV 投影 → 可用 6-bit 或 4-bit
中等： FFN 上投影（W_up/W_gate） → 可用 4-bit
最鲁棒：FFN 下投影（W_down） → 可用 4-bit 甚至 3-bit
最鲁棒：Embedding 层 → 可用 4-bit
层级规律：
早期层比晚期层更敏感（梯度流经更多变换）
→ 可对早期层使用更高精度
实际策略（IQP 最优化）：
min Σᵢ sensitivity(i) × compression_cost(bᵢ)
s.t. Σᵢ params(i) × bᵢ ≤ 总比特预算
bᵢ ∈ {2, 3, 4, 8, 16}
4.7 量化选型矩阵¶
| 场景 | 推荐方案 | 理由 |
|---|---|---|
| GPU 高吞吐服务 | AWQ 4-bit + Marlin 内核 | 最快吞吐（741 tok/s），质量保留 95% |
| GPU 单卡部署 | GPTQ 4-bit | 生态最成熟，工具链完善 |
| CPU / Apple Silicon | GGUF Q4_K_M | 统一内存优势，消除 PCIe 瓶颈 |
| W8A8 全链路量化 | SmoothQuant | 激活+权重全量化，可用 INT8 Tensor Core |
| KV Cache 量化 | KIVI 2-bit / NVFP4 | 见第 2 章 |
| 极端压缩研究 | GPTQ 2-bit + 混合精度 | 需要逐层敏感度分析 |
5 三条路径的协同：生产级推理优化栈¶
5.1 每条路径解决什么瓶颈¶
推理瓶颈 优化路径 效果
───────────────────────────────────────────────────────────────────────
注意力 IO 浪费 FlashAttention-3
N² 中间矩阵反复读写 HBM ──→ Tiling + Online Softmax ──→ IO ÷ 9
GPU 利用率仅 25% Warp-specialization 利用率 85%
逐 token 解码太慢 投机解码
每个 token 独立调用大模型 ──→ EAGLE-3 猜 5 验 1 ──→ 大模型调用 ÷ 4
99% 算力空转等搬运 Medusa 单模型多头 最高 6.5×
模型太大 / 搬运太慢 量化
70B FP16 = 140 GB ──→ AWQ / GPTQ 4-bit ──→ 体积 ÷ 4
每 token 搬运 140 GB SmoothQuant W8A8 搬运 ÷ 4
KV Cache 膨胀 / 服务效率低 系统优化（详见第 2 章）
缓存碎片、请求排队等待 ──→ PagedAttention + 连续批处理──→ 吞吐 2–4×
前缀重复计算 前缀缓存 + P/D 分离 吞吐 5–30×
5.2 叠加原则与典型生产栈¶
多数优化方案可以正交叠加。典型的生产级推理系统：
用户请求到达
│
▼
┌───────────────────────────────────────────────────────┐
│ 量化层 │
│ 权重：AWQ/GPTQ 4-bit → 模型体积 ÷ 4 │
│ KV Cache：FP8/INT8/KIVI 2-bit → 缓存体积 ÷ 2–8 │
│ 激活：SmoothQuant W8A8（可选） → 全链路 INT8 计算 │
└─────────────────────┬─────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────┐
│ 计算层：FlashAttention-3 │
│ IO-aware tiling + Online Softmax → HBM 访问 ÷ 9 │
│ Warp-specialization → 利用率 85% │
│ FlashDecoding → Decode KV 并行 │
└─────────────────────┬─────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────┐
│ 解码层：投机解码 │
│ EAGLE-3 草稿猜 5 token → 大模型验证 → 接受 ~4 个 │
│ 大模型调用次数 ÷ 4 │
│ batch 场景 → P-EAGLE 并行草稿 + slot-based KV │
└─────────────────────┬─────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────┐
│ 系统层（详见第 2 章） │
│ GQA/MLA → KV 头压缩，缓存从源头减小 │
│ PagedAttention → 分页管理，碎片 <4% │
│ 连续批处理 → 迭代级调度，GPU 利用率提升 │
│ 前缀缓存 → 共享 prompt 复用，吞吐 5× │
│ Prefill-Decode 分离 → 异构硬件匹配，吞吐 4.48× │
└───────────────────────────────────────────────────────┘
5.3 场景选型指南¶
| 场景 | 推荐组合 | 预期效果 |
|---|---|---|
| 低延迟在线对话 | FA-3 + EAGLE-3 + AWQ 4-bit | 单请求延迟降低 4–6× |
| 高吞吐 API 服务 | FA-3 + SmoothQuant W8A8 + 连续批处理 + 前缀缓存 | 吞吐提升 5–10× |
| 单卡部署 70B | GPTQ 4-bit + FA-2 + Medusa | 70B 模型单 A100 可推理 |
| 端侧/移动推理 | GGUF 4-bit + Staged Spec + 滑动窗口注意力 | 手机/笔记本运行 7B |
| 超长上下文（>128K） | FA-3 + StreamingLLM + KV 量化 + PagedAttention | 百万 token 上下文 |
| 集群级部署 | 全栈叠加 + Disaggregated Serving + KV-Aware Routing | 30× 吞吐（Dynamo） |
6 关键论文时间线¶
| 论文 | 会议/年份 | 核心贡献 |
|---|---|---|
| FlashAttention [8] | NeurIPS 2022 | IO-aware tiling，消除 N² IO，开启长上下文 |
| SpecDec [3] | 2022 | 投机解码系统化研究起点，seq2seq ~5× |
| GPTQ [11] | 2022 | Hessian 补偿 3-4bit PTQ，175B 单卡推理 |
| SmoothQuant [12] | 2022 | 激活平滑等价变换，W8A8 全链路量化 |
| FlashAttention-2 [9] | 2023 | 并行划分优化，50–73% 利用率，2× 提速 |
| Speculative Sampling [2] | DeepMind 2023 | 拒绝采样数学框架，分布一致加速 |
| Online Spec Decoding [4] | 2023 | 在线蒸馏持续提升接受率 |
| Staged Spec Decoding [5] | 2023 | 树形草稿，端侧 3.16× |
| GQA [13] | EMNLP 2023 | 5% 算力 uptraining KV 头压缩 |
| AWQ | MIT 2023 | 激活感知权重量化，95% 质量保留 |
| Medusa [7] | 2024 | 多解码头，单模型投机，2.3–3.6× |
| ParallelSpec [6] | 2024 | 并行草稿，2.84× |
| EAGLE-2 | EMNLP 2024 | 动态草稿树，3.05–4.26× |
| FlashAttention-3 | 2024 | H100 warp-specialization，85% 利用率 |
| EAGLE-3 [1] | NeurIPS 2025 | token 预测 + scaling law，最高 6.5× |
| Mirror SD (Apple) | 2025 | 双向异构投机，2.8–5.8× |
| P-EAGLE (AWS) | 2025 | 并行 EAGLE，vLLM 原生，+1.69× |
7 总结：一张图回顾¶
用户请求到达
│
▼
┌───────────────────────────────────────────────────────────────┐
│ ① 模型压缩层：量化 │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 权重量化 │ │ 激活量化 │ │ KV Cache 量化 │ │
│ │ AWQ / GPTQ │ │ SmoothQuant │ │ KIVI / NVFP4 │ │
│ │ 4-bit │ │ W8A8 │ │ 2–4 bit │ │
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
│ └─────────────────┴─────────────────┘ │
│ 体积 ÷ 4 · 搬运 ÷ 4 · 可用 INT8 Tensor Core │
└───────────────────────────┬───────────────────────────────────┘
│
┌───────────────────────┴───────────────────────┐
▼ ▼
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ ② Prefill：FlashAttention │ │ ③ Decode：投机解码 │
│ │ │ │
│ Online Softmax + Tiling │ │ EAGLE-3 草稿模型 │
│ ┌─────┐ ┌─────┐ ┌─────┐ │ │ 猜 5 token │
│ │Q blk│ │K blk│ │V blk│ │ │ ↓ │
│ └─────┘ └─────┘ └─────┘ │ │ 大模型 1 次验证 │
│ 全在 SRAM，不写 N² 到 HBM │ │ ↓ │
│ │ │ 接受 4 个 → 调用 ÷ 4 │
│ FlashDecoding： │ │ │
│ KV 序列切片并行加载 │ │ Medusa：单模型多头 │
│ │ │ Mirror SD：异构双向 │
│ IO ÷ 9 · 利用率 85% │ │ P-EAGLE：batch 并行草稿 │
└──────────────┬──────────────┘ └──────────────┬──────────────┘
└───────────────┬────────────────┘
│
▼
┌───────────────────────────────────────────────────────────────┐
│ ④ Serving 系统层（详见第 2 章） │
│ │
│ ┌─────────────────┐ ┌──────────────┐ ┌─────────────────┐ │
│ │ PagedAttention │ │ 连续批处理 │ │ 前缀缓存 │ │
│ │ 分页 KV · CoW │ │ 迭代级调度 │ │ RadixAttention │ │
│ │ 碎片 <4% │ │ 无等待插入 │ │ 吞吐 5× │ │
│ └─────────────────┘ └──────────────┘ └─────────────────┘ │
│ ┌─────────────────────────────────────┐ │
│ │ Prefill-Decode 分离 + KV-Aware 路由 │ ← 集群级 │
│ │ 异构硬件匹配 · 吞吐 4.48–30× │ │
│ └─────────────────────────────────────┘ │
└───────────────────────────┬───────────────────────────────────┘
│
▼
生成完成 → 返回用户
推理优化不是单点技术，而是多层叠加的系统工程。量化从数据精度切入，FlashAttention 和投机解码分别优化 Prefill 和 Decode 两个阶段，Serving 系统在集群层面释放最后的效率。四层叠加，构成从硬件到算法到系统的完整推理加速栈。
References¶
- Li, Y., Wei, F., Zhang, C., & Zhang, H. (2025). EAGLE-3: Scaling up Inference Acceleration of Large Language Models via Training-Time Test. NeurIPS 2025. https://arxiv.org/abs/2503.01840
- Chen, C., Borgeaud, S., Irving, G., Lespiau, J.-B., Sifre, L., & Jumper, J. (2023). Accelerating Large Language Model Decoding with Speculative Sampling. DeepMind. https://arxiv.org/abs/2302.01318
- Xia, H., Ge, T., Wang, P., Chen, S.-Q., Wei, F., & Sui, Z. (2022). Speculative Decoding: Exploiting Speculative Execution for Accelerating Seq2seq Generation. https://arxiv.org/abs/2203.16487
- Liu, X., Hu, L., Bailis, P., Cheung, A., Deng, Z., Stoica, I., & Zhang, H. (2023). Online Speculative Decoding. https://arxiv.org/abs/2310.07177
- Spector, B. & Re, C. (2023). Accelerating LLM Inference with Staged Speculative Decoding. https://arxiv.org/abs/2308.04623
- Xiao, Z., Zhang, H., Ge, T., Ouyang, S., Ordonez, V., & Yu, D. (2024). ParallelSpec: Parallel Drafter for Efficient Speculative Decoding. https://arxiv.org/abs/2410.05589
- Cai, T., Li, Y., Geng, Z., Peng, H., Lee, J. D., Chen, D., & Dao, T. (2024). Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads. https://arxiv.org/abs/2401.10774
- Dao, T., Fu, D. Y., Ermon, S., Rudra, A., & Ré, C. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022. https://arxiv.org/abs/2205.14135
- Dao, T. (2023). FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning. https://arxiv.org/abs/2307.08691
- Kwon, W., Li, Z., Zhuang, S., Sheng, Y., Zheng, L., Yu, C. H., Gonzalez, J. E., Zhang, H., & Stoica, I. (2023). Efficient Memory Management for Large Language Model Serving with PagedAttention. SOSP 2023. https://arxiv.org/abs/2309.06180
- Frantar, E., Ashkboos, S., Hoefler, T., & Alistarh, D. (2022). GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers. https://arxiv.org/abs/2210.17323
- Xiao, G., Lin, J., Seznec, M., Wu, H., Demouth, J., & Han, S. (2022). SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models. https://arxiv.org/abs/2211.10438
- Ainslie, J., Lee-Thorp, J., de Jong, M., Zemlyanskiy, Y., Lebrón, F., & Sanghai, S. (2023). GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints. EMNLP 2023. https://arxiv.org/abs/2305.13245
- Wan, Z., Wang, X., Liu, C., Alam, S., Zheng, Y., et al. (2024). A Survey on Efficient Inference for Large Language Models. https://arxiv.org/abs/2404.14294
- NVIDIA. (2023). Mastering LLM Techniques: Inference Optimization. https://developer.nvidia.com/blog/mastering-llm-techniques-inference-optimization/
- Lienhart, P. (2023). LLM Inference Series: KV Caching, A Deeper Look. https://medium.com/@plienhar/llm-inference-series-4-kv-caching-a-deeper-look-4ba9a77746c8
- Chen, Z., Gao, S., Nguyen, E., et al. (2024). MagicDec: Breaking the Latency-Throughput Tradeoff for Long Context Generation with Speculative Decoding. ICLR 2025. https://arxiv.org/abs/2408.11049
本章未编号引用的论文：
- Li, Y., Wei, F., Zhang, C., & Zhang, H. (2024). EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty. ICML 2024. https://arxiv.org/abs/2401.15077
- Li, Y., Wei, F., Zhang, C., & Zhang, H. (2024). EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees. EMNLP 2024. https://arxiv.org/abs/2406.16858
- Lin, J., Tang, J., Tang, H., Yang, S., Dang, X., & Han, S. (2023). AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration. MLSys 2024. https://arxiv.org/abs/2306.00978
- Dao, T., Haziza, D., Mudayy, F., & Ramani, A. (2024). FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision. https://arxiv.org/abs/2407.08608
- Hong, C., Duber, A., Ajmeri, K., et al. (2024). FlashDecoding++: Faster Large Language Model Inference on GPUs. MLSys 2024. https://arxiv.org/abs/2311.01282
- Apple Machine Learning Research. (2025). Mirror Speculative Decoding. https://machinelearning.apple.com/research/mirror
- AWS & vLLM. (2025). P-EAGLE: Faster LLM Inference with Parallel Speculative Decoding in vLLM. https://aws.amazon.com/blogs/machine-learning/p-eagle-faster-llm-inference-with-parallel-speculative-decoding-in-vllm/
- Leviathan, Y., Kalman, M., & Matias, Y. (2023). Fast Inference from Transformers via Speculative Decoding. ICML 2023. https://arxiv.org/abs/2211.17192