---
tags: [AI, inference, 量化]
阶段: 08-Agent与工程化
难度: ★★★
created: 2026-10-18
related: "[[KV缓存]], [[分组查询注意力GQA]], [[分布式训练与部署]], [[成本-延迟-质量权衡]]"
---

# 模型推理优化

## 定义

**推理优化**（inference optimization）指在给定硬件、数值精度与延迟上限的约束下，通过修改数值表示、请求组织方式、计算图结构与解码策略，减少单 token 所需的显存读写字节数与浮点运算量，从而提高单位时间产出 token 数并压低延迟尾部的一类工程方法。

一次自回归推理请求的代价由下列量共同决定。符号在全文保持一致。

| 符号 | 含义 | 单位 |
|---|---|---|
| $P$ | 模型参数量，用于计算权重字节数与矩阵乘 FLOP | 个 |
| $b_w$ | 每个参数占用的字节数，bf16 为 2，INT4 约为 0.5 | 字节 |
| $S$ | 输入（prompt）token 数，决定 prefill 长度 | 个 |
| $N$ | 输出 token 数 | 个 |
| $L$ | Transformer 层数 | 层 |
| $h$ | 隐藏维度 | 维 |
| $n_{kv}$ | KV 头数，多头注意力下等于头数，GQA 下小于头数 | 个 |
| $d$ | 每个注意力头的维度，满足 $n_{h}d=h$ | 维 |
| $B$ | 同时处理的序列数（批大小） | 条 |
| $BW$ | 显存带宽 | 字节/秒 |
| $P_{\text{peak}}$ | 峰值浮点算力 | FLOP/秒 |
| $I$ | 算术强度，每字节显存流量对应的 FLOP 数 | FLOP/字节 |

术语按首次出现处定义。**预填充**（prefill）是把全部输入 token 一次性送入网络、并行计算各位置隐状态的过程；**解码**（decode）是按位置逐个生成输出 token 的过程，第 $t$ 步依赖第 $t-1$ 步的结果；**首 token 延迟**（time to first token，TTFT）是从请求到达到第一个输出 token 返回的时间；**每输出 token 时间**（time per output token，TPOT）是解码阶段相邻两个 token 的平均间隔；**量化**（quantization）是把浮点张量映射到低位宽整数或低精度浮点并表示反变换的过程；**校准**（calibration）是用一批代表性输入统计激活或权重的动态范围，以确定量化参数的过程；**蒸馏**（distillation）是让小模型拟合大模型输出分布的训练方法；**投机解码**（speculative decoding）是用廉价草稿模型先猜若干 token、再由目标模型一次并行验证的解码方法。

## 为什么重要

训练成本按次支付，推理成本按请求支付，且请求数随用户数线性增长。两者的资源瓶颈不同：训练阶段每步处理大量 token，矩阵乘的算术强度高，受算力限制；解码阶段每步只处理一个 token，必须把全部权重从显存读入计算单元，受带宽限制。

以 7B 模型、bf16 权重、A100-80G 为例。权重共 $2P=14\times10^{9}$ 字节，单次解码步的显存读取量至少为 14 GB，带宽 2.039 TB/s，因此单序列解码速度上界为

$$
\frac{BW}{2P}=\frac{2.039\times10^{12}}{14\times10^{9}}\approx 146\ \text{token/s}.
$$

同一张卡的算力上界为 $P_{\text{peak}}/(2P)=312\times10^{12}/(14\times10^{9})\approx 2.2\times10^{4}$ token/s。两者相差约 150 倍。这个差距说明：在批大小为 1 时，算力有 99% 以上处于空闲，唯一的改进方向是减少每步必须搬运的字节数，或让多条序列共享同一次权重搬运。

没有推理优化会产生四类具体后果。第一类是容量后果：7B 模型在 bf16 下占 14 GB，若按 fp32 部署则占 28 GB，单卡可容纳的并发序列数减半。第二类是延迟后果：KV Cache 不做分页管理时，为最长可能序列预留连续显存会造成 60% 以上的浪费，可用并发数下降，排队延迟上升。第三类是成本后果：解码吞吐与每步字节数成反比，权重位宽每降一半，同一张卡的服务能力约翻倍。第四类是尾延迟后果：静态批处理让一个长请求阻塞整批，P95 延迟由批内最长序列决定。

在本库中的位置是执行层。[[KV缓存]] 给出缓存的结构与字节数公式，[[分组查询注意力GQA]] 给出减小 $n_{kv}$ 以压缩缓存的机制，本篇讨论在这些结构之上如何用数值表示、批处理组织、解码策略与编译手段把硬件利用率提高；[[分布式训练与部署]] 讨论多卡切分与部署形态，[[成本-延迟-质量权衡]] 把这些性能量换算成单位请求成本与 SLO。对应学习目标中的"能复现"与"会评估"：能写出量化与投机解码的可运行实现，能根据硬件参数判断一个请求是算力受限还是带宽受限。

## 原理与推导

### 1 两阶段的划分与计算特征

设输入长 $S$，输出长 $N$。单层线性变换的参数量约为 $P/L$，单层注意力部分的计算量为 $4S^{2}h$ FLOP（打分矩阵 $QK^{\top}$ 为 $2S^{2}h$，加权求和 $AV$ 为 $2S^{2}h$，均按一次乘加计 2 FLOP）。

预填充一次前向的总计算量为

$$
F_{\text{prefill}}\approx 2PS+4LS^{2}h ,
$$

第一项是全部线性层对 $S$ 个 token 的矩阵乘，第二项是注意力的二次项。解码一步（生成一个 token）的计算量为

$$
F_{\text{decode}}\approx 2P+4LSh ,
$$

其中 $2P$ 是线性层对单个 token 的矩阵乘，$4LSh$ 是新 token 对已有 $S$ 个位置的注意力。

代入 $P=7\times10^{9}$、$L=32$、$h=4096$：当 $S=4096$ 时，$2PS=5.7\times10^{13}$，$4LS^{2}h=8.8\times10^{12}$，注意力占 13%；当 $S=32768$ 时，$2PS=4.6\times10^{14}$，$4LS^{2}h=5.6\times10^{14}$，注意力占 55%。这说明长上下文把预填充从"线性层主导"推向"注意力主导"，也是 FlashAttention 一类 IO 优化在长上下文下收益更大的原因。

两阶段的显存流量差别决定了瓶颈归属。预填充一次读入全部权重并复用 $S$ 次，算术强度约为

$$
I_{\text{prefill}}\approx\frac{2PS}{2P}=S ,
$$

当 $S$ 大于硬件的算力带宽比时属于算力受限。解码一步同样读入全部权重，却只产生一个 token，算术强度约为

$$
I_{\text{decode}}\approx\frac{2P}{2P+\text{KV 读取字节}}\approx 1 ,
$$

远低于任何现代加速器的算力带宽比，属于带宽受限。

| 维度 | 预填充 | 解码 |
|---|---|---|
| 并行度 | 沿序列维完全并行 | 沿序列维串行，仅批维并行 |
| 主要计算 | 大矩阵乘 $S\times h$ 乘 $h\times h$ | 矩阵向量乘 $1\times h$ 乘 $h\times h$ |
| 算术强度 | 约 $S$ | 约 1 |
| 瓶颈 | 算力 | 显存带宽 |
| 决定指标 | TTFT | TPOT |
| 优化手段 | 融合、FlashAttention、chunked prefill | 量化权重、增大批、KV 分页、投机解码 |

### 2 Roofline 模型与算术强度

Roofline 模型把一次计算的最短时间写成算力与带宽两个上界的较大者：

$$
T=\max\left(\frac{F}{P_{\text{peak}}},\ \frac{M}{BW}\right),
$$

其中 $F$ 为浮点运算数，$M$ 为必须从显存搬运的字节数。令两者相等可得拐点算术强度

$$
I^{*}=\frac{P_{\text{peak}}}{BW}.
$$

$I^{*}$ 是硬件的固有属性，与模型无关。A100-SXM 的 bf16 稠密算力为 $312$ TFLOPS、带宽为 $2.039$ TB/s，$I^{*}\approx153$ FLOP/字节；H100-SXM 的 bf16 稠密算力约为 $990$ TFLOPS、带宽为 $3.35$ TB/s，$I^{*}\approx295$ FLOP/字节。当一次计算的 $I<I^{*}$ 时，把算力再提高一倍不会缩短时间；只有减少字节数或提高数据复用才有用。

由此可推出三条结论。第一，解码的 $I\approx1$ 比 $I^{*}$ 小两个数量级以上，因此解码优化的核心是压低 $M$：权重量化、KV 量化、增大批以摊薄权重读取。第二，增大批不改变权重的字节数，却让 $B$ 条序列共享一次读取，等效算术强度提升到约 $B$；这是连续批处理能提高吞吐的定量原因。第三，批增大到一定程度后，KV Cache 的读取字节超过权重字节，此时再增大批只增加读带宽压力，吞吐趋于饱和。

### 3 显存构成与 KV Cache 公式

部署时的显存分为三块：权重 $P b_w$；KV Cache；激活与临时缓冲。KV Cache 的字节数为

$$
M_{\text{kv}}=2\cdot L\cdot n_{kv}\cdot d\cdot b_{kv}\cdot T_{\text{total}},
$$

其中系数 2 表示 K 与 V 两份，$b_{kv}$ 为缓存元素位宽对应的字节数，$T_{\text{total}}$ 为该副本上所有并发序列的 token 总数（含 prompt 与已生成部分）。

以 Llama-2 系列在 bf16（$b_{kv}=2$）下为例：7B 的 $L=32$、$n_{kv}=32$、$d=128$，每 token 为 $2\times32\times32\times128\times2=524288$ 字节，即 512 KiB；13B 的 $L=40$、$n_{kv}=40$，每 token 为 800 KiB；70B 采用 GQA，$L=80$、$n_{kv}=8$，每 token 为 320 KiB。若改用 4 bit 缓存（$b_{kv}=0.5$），三者的每 token 字节数分别降到 128 KiB、200 KiB、80 KiB。

容量约束给出并发上限。80 GB 卡上部署 7B，权重 14 GB，留 2 GB 给激活与框架，剩余 64 GiB 可用于缓存。按 512 KiB/token 与 2048 长度计算，单条序列占 1 GiB，因此最多同时驻留 $64\times2^{30}/(524288\times2048)=64$ 条；同样预算下 32k 长度单条占 16 GiB，只能驻留 4 条。这说明长上下文对并发的压缩是按长度线性、按总量守恒的。

### 4 量化：映射、粒度与误差

均匀量化的对称形式为

$$
q=\operatorname{clamp}\left(\operatorname{round}\left(\frac{x}{s}\right),-2^{b-1},\,2^{b-1}-1\right),\qquad \hat{x}=s\cdot q ,
$$

其中 $s$ 为缩放因子（scale），$b$ 为位宽，$\hat{x}$ 为反量化结果。取 $s=\max|x|/(2^{b-1}-1)$ 时，全张量的绝对值最大值恰好落在 $2^{b-1}-1$ 上。若分母误用 $2^{b-1}$，步长缩小为原来的 $(2^{b-1}-1)/2^{b-1}$，绝对值最大的元素量化后得到 $2^{b-1}$，超出上界被截断，误差约一个完整步长，是舍入上界 $s/2$ 的两倍。若只做 `round` 而不做 `clamp`，超出范围的值在转成 INT8 时溢出，结果依赖平台，可能回绕为负值，误差等于整个动态范围。

非对称形式额外引入零点

$$
q=\operatorname{clamp}\left(\operatorname{round}\left(\frac{x}{s}\right)+z,\,0,\,2^{b}-1\right),\qquad
s=\frac{x_{\max}-x_{\min}}{2^{b}-1},\qquad z=\operatorname{round}\left(-\frac{x_{\min}}{s}\right),
$$

其优点是能把任意区间 $[x_{\min},x_{\max}]$ 映射到全部 $2^{b}$ 个码点，适合经过 ReLU 或分布在单侧的激活；代价是每个张量多存一个 $z$，且反量化多一次减法。

误差的上界由步长决定。舍入误差满足 $|x-\hat{x}|\le s/2$。若假设 $x$ 在量化区间内均匀分布，误差方差为 $s^{2}/12$。对满量程均匀分布信号，信号功率为 $1/3$，噪声功率为 $s^{2}/12=(2/2^{b})^{2}/12$，于是

$$
\text{SNR}=10\log_{10}\frac{1/3}{1/(3\cdot4^{b})}=6.02b\ \text{dB}.
$$

每增加 1 bit 约提升 6 dB，即误差减半。实际权重近似高斯分布且按最大值定标，有效 SNR 低于该上界，8 bit 实测约 40 dB。

量化粒度决定误差是否被离群通道放大。**逐张量**（per-tensor）为整个矩阵用一个 $s$；**逐通道**（per-channel）为每个输出通道用一个 $s$，权重矩阵按行分组；**分组**（group-wise）在通道内再按固定长度（常见 32、64、128）分组。若各通道动态范围相差 10 倍而共用逐张量 scale，小范围通道的权重会被舍入到少数几个码点甚至全为零。逐通道与分组的代价是额外存储：4 bit、分组 128 时，每 128 个权重需 2 字节 fp16 scale，平均位宽从 4 升至 $4+16/128=4.125$ bit。

按量化时机分两类。**训练后量化**（post-training quantization，PTQ）只用少量校准数据确定 $s$ 与 $z$，不需要反向传播，成本是数分钟到数小时；**量化感知训练**（quantization-aware training，QAT）在前向中插入伪量化节点，用直通估计器（straight-through estimator，STE）把梯度原样传过舍入操作，让权重在训练中适应量化噪声。QAT 通常比 PTQ 多保留 1 至 2 bit 的等效精度，代价是一次完整训练。

| 方案 | 权重 | 激活 | 显存降幅 | 典型精度影响 | 适用场景 |
|---|---|---|---|---|---|
| W8A16 | INT8 逐通道 | 不量化 | 约 50% | 很小 | 通用，兼容性最好 |
| W8A8 | INT8 逐通道 | INT8 逐 token 动态 | 约 50% | 小，需处理激活离群值 | 高吞吐服务 |
| FP8 | E4M3 | E4M3 逐 token | 约 50% | 小，动态范围优于 INT8 | H100 及更新硬件 |
| W4A16 | 4 bit 分组 128 | 不量化 | 约 75% | 中等，需 GPTQ/AWQ 类算法 | 单卡部署大模型 |
| W4A8 | 4 bit | INT8 | 约 75% | 较大，需校准集覆盖分布 | 显存极紧场景 |

FP8 的两个常用格式是 E4M3（3 位尾数、最大可表示 448）与 E5M2（2 位尾数、最大 57344）。E4M3 在 $[1,2)$ 区间的步长为 $2^{-3}$，相对误差上界 $2^{-4}=6.25\%$；它比 INT8 的优势在于指数位提供了跨数量级的动态范围，不必为离群值牺牲整体分辨率。

4 bit 只有 16 个码点，逐张量几乎不可用，因此实际方案都建立在分组与误差补偿上。**GPTQ** 的核心是按列逐次量化并补偿剩余列：对某层输入 $X$，令 $H=2XX^{\top}$ 为海森矩阵，量化第 $j$ 列产生误差 $e=w_{j}-q_{j}s$，把 $e\cdot H^{-1}_{:,j}$ 加到尚未量化的列上，然后继续下一列。这样每一列的误差被后续列部分抵消，整层输出误差显著低于独立量化。块大小取 128、阻尼系数取 0.01 量级是常见配置。**AWQ** 的核心观察是：权重的重要性由与之相乘的激活幅值决定，而非权重自身的绝对值。它对每个输入通道估计平均激活幅值 $s_{X}$，用缩放系数 $s=s_{X}^{\alpha}$ 把显著通道放大、同时在激活侧除以 $s$ 保持数学等价，再做 4 bit 量化；$\alpha$ 在 $[0,1]$ 上网格搜索。因为只做通道缩放与舍入误差搜索，AWQ 不依赖反向传播，校准成本低于 GPTQ。

### 5 KV Cache 量化

KV Cache 的量化与权重不同：它在推理过程中动态增长，且不同 token 的数值分布差异很大。K 的离群值集中在固定通道上（与激活的通道离群同源），因此 K 常按通道（head 维）分组量化；V 的分布更接近逐 token 独立，常按 token 分组量化。分组长度取 32 或 64，并为每个分组存 fp16 的 scale 与 zero-point。

收益是直接的：由第 3 节的公式，$b_{kv}$ 从 2 降到 0.5 时缓存字节数降为四分之一，并发数约提升四倍；解码每步读取的 KV 字节同步下降，在长上下文、批较大时这部分已成为主要流量。代价体现在需要精确回忆的任务上：键值被舍入后，注意力权重的相对次序可能改变，长上下文检索与多跳问答的准确率下降通常比困惑度上升更明显。工程上常见的折中是保留最近若干 token 与最初若干 token 为 fp16，只对中间段做低位量化。

### 6 蒸馏

设教师模型 logits 为 $z^{T}$，学生为 $z^{S}$，温度为 $\tau$ 的软标签定义为

$$
p_{i}^{(\tau)}=\frac{\exp(z_{i}/\tau)}{\sum_{j}\exp(z_{j}/\tau)} .
$$

蒸馏损失为交叉熵与软标签 KL 的加权和：

$$
\mathcal{L}=(1-\lambda)\,\mathrm{CE}\left(y,p^{S(1)}\right)+\lambda\,\tau^{2}\,\mathrm{KL}\left(p^{T(\tau)}\,\|\,p^{S(\tau)}\right).
$$

因子 $\tau^{2}$ 的作用可由梯度推出。对 $\mathrm{KL}$ 关于学生 logits 求导，链式法则带出 softmax 对温度的 $1/\tau$ 因子：

$$
\frac{\partial\,\mathrm{KL}}{\partial z_{i}^{S}}=\frac{1}{\tau}\left(p_{i}^{S(\tau)}-p_{i}^{T(\tau)}\right).
$$

在 $\tau\to\infty$ 时 softmax 线性化，$p_{i}^{(\tau)}\approx\frac{1}{n}+\frac{z_{i}-\bar{z}}{n\tau}$，代回得梯度量级为 $1/\tau^{2}$。乘 $\tau^{2}$ 后梯度量级与温度无关，否则调高温度会同时把学习率等效调低。软标签携带的信息是类间相似结构：教师给错误类别分配的非零概率编码了哪些类别容易被混淆，这部分信息在硬标签中不存在，也是小模型在同等数据下超过直接监督训练的原因。

### 7 剪枝与稀疏

剪枝按是否保持结构分为两类。非结构化剪枝把单个权重置零，精度损失小，但产生的稀疏矩阵在通用硬件上不能直接加速，除非稀疏度符合结构化模式。结构化剪枝移除整个注意力头、FFN 中间维度或整层，形状规则、可直接缩短计算，但对精度的影响更大，通常需要再训练恢复。

2:4 半结构化稀疏是硬件支持的特例：每 4 个连续权重中恰好保留 2 个，Ampere 及之后的张量核对其提供 2 倍于稠密矩阵乘的吞吐。选哪些权重保留决定精度：按幅值选择忽略了激活幅值，**Wanda** 用 $|w_{ij}|\cdot\|X_{j}\|_{2}$ 作为重要性分数，即权重幅值乘以对应输入通道的激活范数，在同等稀疏度下优于纯幅值准则。层内重建类方法（SparseGPT）沿用与 GPTQ 相同的逐列误差补偿框架，只是把"量化"换成"置零"。

### 8 批处理、连续批处理与 PagedAttention

静态批处理把一批请求同时开始、同时结束，必须把序列补齐到批内最长长度。设批内长度为 $\{S_{i}\}$，浪费比例为

$$
\text{waste}=1-\frac{\sum_{i}S_{i}}{B\cdot\max_{i}S_{i}} .
$$

长度分布离散时该比例常达 50% 以上，且整批的完成时间由最长请求决定，短请求被迫等待。

连续批处理（continuous batching，亦称 iteration-level scheduling）把调度粒度从请求改为解码步：每步结束后，已完成的序列立即退出并释放其 KV 块，新请求立即加入。批的组成随步变化，因此不存在"整批等待最慢者"的问题。其吞吐收益来自第 2 节的结论：权重读取被更多序列分摊，等效算术强度随批大小上升。

PagedAttention 解决缓存的分配问题。它为每条序列维护块表（block table），把逻辑位置映射到固定大小的物理块（默认 16 个 token），块可以不连续。于是缓存按需分配，内部碎片至多 $15$ 个 token/序列，外部碎片为零；相同前缀的序列可以共享物理块，写时复制。论文报告在同等延迟下吞吐提升 2 至 4 倍，主要来源是浪费率从 60% 至 80% 降到 4% 以下。

```mermaid
flowchart LR
    A["请求到达"] --> B{"有空闲块"}
    B -- "是" --> C["分配逻辑块并写入块表"]
    B -- "否" --> D["抢占或排队"]
    C --> E["按块表拼接 KV 并解码一步"]
    E --> F{"序列结束"}
    F -- "是" --> G["释放物理块并回收"]
    F -- "否" --> E
```

### 9 投机解码

设草稿模型每步猜 $\gamma$ 个 token，目标模型一次前向并行验证这 $\gamma$ 个位置。验证规则是：对第 $i$ 个草稿 token，以概率 $\min\left(1,p(x_{i})/q(x_{i})\right)$ 接受，被拒绝时从修正分布 $(p-q)_{+}$ 归一化后采样。该规则保证最终输出分布与直接用目标模型采样完全一致，因此投机解码不改变模型质量，只改变计算组织。

设单 token 的前缀接受率为 $\alpha$，即 $P(\text{接受第 }i\text{ 个}\mid\text{前 }i-1\text{ 个已接受})=\alpha$。一次迭代中被接受的草稿 token 数 $K$ 满足 $P(K\ge k)=\alpha^{k}$，$k=1,\dots,\gamma$。验证全部通过时目标模型还会额外产生 1 个 token，因此每次迭代的期望产出为

$$
\mathbb{E}[\text{tokens}]=\sum_{k=1}^{\gamma}\alpha^{k}+1=\frac{1-\alpha^{\gamma+1}}{1-\alpha}.
$$

设 $c$ 为草稿模型单 token 耗时与目标模型单 token 耗时之比，一次迭代的成本为 $1+\gamma c$ 个目标步。加速比为

$$
\text{speedup}=\frac{1-\alpha^{\gamma+1}}{(1-\alpha)(1+\gamma c)} .
$$

取 $\alpha=0.8$、$\gamma=4$、$c=0.05$，得 $\mathbb{E}[\text{tokens}]=3.36$，加速比 $2.80$。$\gamma$ 增大使 $\mathbb{E}[\text{tokens}]$ 趋近 $1/(1-\alpha)=5$，但成本同步线性增长，因此存在最优 $\gamma$：对 $\alpha=0.8$、$c=0.05$，$\gamma=4$ 给出 2.80，$\gamma=8$ 给出 3.09，$\gamma=8$ 的边际收益已经很小。

$c$ 的估计依赖瓶颈判断。在批大小为 1 的延迟受限区间，验证 $\gamma+1$ 个 token 的耗时与验证 1 个 token 接近（权重读取占主导），因此草稿模型的一次前向耗时约正比于其参数量，$c\approx P_{\text{draft}}/P_{\text{target}}$。在批很大、算力受限的区间，验证 $\gamma+1$ 个位置的成本按 FLOP 线性增长，投机解码几乎不带来吞吐收益，反而占用额外算力。这一区分是判断方案是否适用的前提。

### 10 FlashAttention 的 IO 复杂度

标准注意力把 $S\times S$ 的打分矩阵写入显存再读回做 softmax，仅这一项的显存流量就是 $O(S^{2})$，且需要 $O(S^{2})$ 的存储。FlashAttention 把 $Q$ 分块常驻片上 SRAM，对 $K,V$ 分块流式遍历，用在线 softmax 维护运行时的最大值与归一化因子，使打分矩阵从不完整落盘。其 HBM 访问量为

$$
\Theta\left(\frac{S^{2}d^{2}}{M}\right),
$$

其中 $M$ 为 SRAM 容量。与标准实现的 $O(S^{2})$ 相比，当 $d^{2}<M$ 时流量更低；反向传播不存储 $S\times S$ 矩阵，而是重算，存储从 $O(S^{2})$ 降到 $O(S)$。该算法是精确计算，不是近似，因此与量化、蒸馏等手段正交，可同时使用。

### 11 编译优化与并行解码

算子融合把多个逐元素或归约算子合成一个核函数，避免中间张量往返显存。典型融合包括残差相加与 RMSNorm、旋转位置编码与 QKV 切分、SwiGLU 的两次投影与逐元素乘。以 7B 模型为例，一次解码涉及约 32 层、每层 8 至 12 个核函数，总计 300 个左右；每次核函数启动开销约 3 至 8 微秒，累计 1 至 2.4 毫秒。当 TPOT 为 7 毫秒时，这部分占比可达 15% 至 30%。

CUDA Graph 把整段前向的核函数序列捕获为一张图，重放时只有一次提交，消除逐核启动开销。其代价是要求静态形状，因此需要把批大小与序列长度归入固定桶并补齐；对长度分布离散的在线服务，补齐带来的浪费需要与启动开销的节省做权衡。

并行解码是投机解码的变体。prompt lookup decoding 直接从 prompt 中匹配当前后缀，用命中片段作为草稿，不需要额外模型；多头的 Medusa 方案在目标模型上附加若干预测头，一次前向产生多个候选位置，再用树形注意力验证。它们的共同点是保持目标分布不变，只改变候选产生方式。

### 12 延迟指标与吞吐

端到端延迟可分解为

$$
L_{\text{e2e}}=L_{\text{queue}}+\text{TTFT}+(N-1)\cdot\text{TPOT},
$$

其中 $L_{\text{queue}}$ 为排队时间，$(N-1)$ 是因为首 token 已计入 TTFT。TTFT 由排队与预填充组成，预填充时间约 $F_{\text{prefill}}/(P_{\text{peak}}\cdot\text{MFU})$，MFU 为算力利用率；TPOT 由解码步时间组成，受带宽与批大小共同影响。

服务指标必须区分三个量。**吞吐**（throughput）是单位时间处理的 token 总数或请求总数；**延迟**（latency）是单个请求的端到端时间；**有效吞吐**（goodput）是满足延迟约束的请求吞吐。三者关系由排队论给出：在到达率 $\lambda$、总服务率 $\mu$、利用率 $\rho=\lambda/\mu$ 的系统中，平均排队时间为

$$
\mathbb{E}[W_{q}]=\frac{\rho}{\mu(1-\rho)} .
$$

$\rho=0.8$ 时为 $4/\mu$，$\rho=0.9$ 时为 $9/\mu$，$\rho=0.95$ 时为 $19/\mu$。这说明把利用率从 80% 推到 95% 会让排队延迟增至四倍以上，P95 的恶化幅度更大。吞吐与延迟不是同一目标的两种说法，而是同一条曲线的两个坐标。

## 关键直觉

> [!tip] 解码是"每产出一个 token 就要把整个模型读一遍"的过程，因此其速度上界是带宽除以权重字节数；批处理把这次读取摊给多条序列，量化把字节数直接减半或减到四分之一，投机解码则让一次读取产出多个 token。四种手段作用在同一个量上：每个 token 分摊到的显存流量。预填充不受此限，它把整段输入一次读完，瓶颈是算力与注意力的二次项。这一直觉与第 2 节的形式定义一致：$I<I^{*}$ 时 $T=M/BW$，压缩 $M$ 或增大复用都直接缩短 $T$。

## 例子与代码

### 例 1：对称量化、反量化与误差统计

下面的代码实现第 4 节的对称映射，统计误差并与理论上界 $s/2$ 对照；随后在一个人为构造的、各通道动态范围相差 15 倍的权重矩阵上比较逐张量与逐通道 4 bit 量化的误差。

```python
import numpy as np

rng = np.random.default_rng(0)

def quantize_symmetric(x, bits=8):
    qmax = 2 ** (bits - 1) - 1                  # int8: 127
    scale = np.abs(x).max() / qmax              # 每个张量一个 scale
    q = np.clip(np.round(x / scale), -qmax - 1, qmax)
    return q.astype(np.int8 if bits == 8 else np.int32), scale

def dequantize_symmetric(q, scale):
    return q.astype(np.float32) * scale

x = rng.normal(0.0, 1.0, size=(4, 4096)).astype(np.float32)
q, s = quantize_symmetric(x, 8)
x_hat = dequantize_symmetric(q, s)
err = x - x_hat
print("scale        =", round(float(s), 6))
print("max|err|     =", round(float(np.abs(err).max()), 6), " 界 s/2 =", round(float(s / 2), 6))
print("rmse         =", round(float(np.sqrt((err ** 2).mean())), 6))
print("snr_db       =", round(float(10 * np.log10((x ** 2).mean() / (err ** 2).mean())), 2))
print("饱和比例      =", round(float(np.mean(np.abs(q) == 127)), 6))
```

```text
scale        = 0.031678
max|err|     = 0.015839  界 s/2 = 0.015839
rmse         = 0.009138
snr_db       = 40.75
饱和比例      = 6.1e-05
```

三个观察对应三个设计点。第一，`max|err|` 恰好等于 $s/2$，说明误差被步长硬性限制，且主要来自舍入而非截断；要降低误差只能减小 $s$，即提高位宽或改用分组。第二，SNR 为 40.75 dB，低于 $6.02\times8=48.2$ dB 的理想值，差距来自高斯分布的峰值因子：按最大值定标使有效量化区间远大于信号标准差，多数码点落在低概率区域。第三，饱和比例为 $6.1\times10^{-5}$，即 16384 个元素中恰有 1 个取到码点 127，正是绝对值最大的那一个，其余元素均未触及边界；本例中 `clamp` 因此没有真正截断任何值。若改用 99.9 分位定标以压缩动态范围，则约 16 个尾部元素会越界，此时 `clamp` 才承担实际作用；去掉它，越界值在转成 int8 时溢出，结果依赖平台（回绕为负值或饱和为 127），两者都不可依赖。

```python
W = rng.normal(0.0, 1.0, size=(256, 512)).astype(np.float32)
W *= np.linspace(0.2, 3.0, 256, dtype=np.float32)[:, None]   # 每行量级不同

def q_per_tensor(M, bits=4):
    qmax = 2 ** (bits - 1) - 1
    s = np.abs(M).max() / qmax
    return np.clip(np.round(M / s), -qmax - 1, qmax) * s

def q_per_channel(M, bits=4):
    qmax = 2 ** (bits - 1) - 1
    s = np.abs(M).max(axis=1, keepdims=True) / qmax
    return np.clip(np.round(M / s), -qmax - 1, qmax) * s

for name, fn in [("per-tensor ", q_per_tensor), ("per-channel", q_per_channel)]:
    Wq = fn(W, 4)
    rel_row = np.linalg.norm(W - Wq, axis=1) / np.linalg.norm(W, axis=1)
    print(name, "mse =", round(float(((W - Wq) ** 2).mean()), 6),
          " 行相对误差 max/median =", round(float(rel_row.max()), 4), "/",
          round(float(np.median(rel_row)), 4))
```

```text
per-tensor  mse = 0.241497  行相对误差 max/median = 1.0 / 0.3218
per-channel mse = 0.059957  行相对误差 max/median = 0.1817 / 0.1333
```

逐张量 4 bit 的最大行相对误差为 1.0，表示量级最小的那一行被全部舍入到零：该行数值约为 0.2 量级，而全局步长为 $\max|W|/7\approx1.4$，小于 $0.7$ 的值一律落到 0 码点。均值 MSE 只相差 4 倍，容易让人误判"影响不大"，但逐行看，最差通道的信息被完全破坏。这正是第 4 节"粒度决定误差是否被离群通道放大"的数值证据，也是分组量化把组长度压到 128 以下的理由。

### 例 2：投机解码的接受率与期望加速

代码同时给出第 9 节的解析公式与蒙特卡洛模拟，两者应当一致；随后扫描接受率、草稿长度与成本比。

```python
import numpy as np

def expected_tokens(alpha, gamma):
    return (1.0 - alpha ** (gamma + 1)) / (1.0 - alpha)

def speedup(alpha, gamma, c):
    return expected_tokens(alpha, gamma) / (1.0 + gamma * c)

def simulate(alpha, gamma, c, trials=200000, seed=0):
    rng = np.random.default_rng(seed)
    u = rng.random((trials, gamma))
    accepted = (u < alpha).cumprod(axis=1).sum(axis=1)   # 连续接受的前缀长度
    tokens = accepted + 1
    cost = 1.0 + gamma * c
    return tokens.sum() / (trials * cost)

print("alpha=0.8, gamma=4, c=0.05")
print("  解析 E[tokens] =", round(expected_tokens(0.8, 4), 4))
print("  解析 speedup   =", round(speedup(0.8, 4, 0.05), 4))
print("  模拟 speedup   =", round(simulate(0.8, 4, 0.05), 4))

print("gamma  c     alpha=0.6  0.7    0.8    0.9   0.95")
for gamma in (2, 4, 8):
    for c in (0.02, 0.05, 0.10):
        row = [speedup(a, gamma, c) for a in (0.6, 0.7, 0.8, 0.9, 0.95)]
        print(f"{gamma:5d} {c:5.2f}  " + "  ".join(f"{v:5.2f}" for v in row))
```

```text
alpha=0.8, gamma=4, c=0.05
  解析 E[tokens] = 3.3616
  解析 speedup   = 2.8013
  模拟 speedup   = 2.7991

gamma  c     alpha=0.6  0.7    0.8    0.9   0.95
    2  0.02   1.88   2.11   2.35   2.61   2.74
    2  0.05   1.78   1.99   2.22   2.46   2.59
    2  0.10   1.63   1.82   2.03   2.26   2.38
    4  0.02   2.13   2.57   3.11   3.79   4.19
    4  0.05   1.92   2.31   2.80   3.41   3.77
    4  0.10   1.65   1.98   2.40   2.93   3.23
    8  0.02   2.13   2.76   3.73   5.28   6.38
    8  0.05   1.77   2.28   3.09   4.38   5.28
    8  0.10   1.37   1.78   2.40   3.40   4.11
```

解析值与模拟值相差 0.07%，差异仅来自采样噪声，说明"连续前缀"的截断几何建模与实现一致。表格显示三个规律。第一，$\alpha$ 从 0.8 升到 0.9 的收益大于 $c$ 从 0.05 降到 0.02：提高接受率是主要杠杆，而接受率由草稿模型与目标模型的分布一致性决定。第二，$\gamma$ 增大在 $c$ 小时单调有用，在 $c=0.1$ 时 $\gamma=8$ 相对 $\gamma=4$ 的增益从 3.09 降到 2.40，说明草稿模型越贵，越应缩短猜测长度。第三，$\alpha=0.6$、$\gamma=8$、$c=0.1$ 时加速比只有 1.37，已低于更新硬件或换更小模型的收益，此时应放弃投机。

### 例 3：显存与带宽估算

下面三个函数分别计算 KV 每 token 字节、解码吞吐与序列级缓存占用，可直接用于容量规划。

```python
def kv_bytes_per_token(L, n_kv, d_head, bytes_per_elem=2):
    return 2 * L * n_kv * d_head * bytes_per_elem        # 2 = K 与 V

def kv_gib(L, n_kv, d_head, seq_len, bytes_per_elem=2):
    return kv_bytes_per_token(L, n_kv, d_head, bytes_per_elem) * seq_len / 2 ** 30

def decode_tokens_per_sec(P, kv_per_token, seq_len, batch, bw, bytes_w=2):
    bytes_per_step = P * bytes_w + batch * seq_len * kv_per_token
    return batch * bw / bytes_per_step

for name, L, nkv, d in [("Llama-2-7B ", 32, 32, 128),
                        ("Llama-2-13B", 40, 40, 128),
                        ("Llama-2-70B", 80, 8, 128)]:
    print(name, kv_bytes_per_token(L, nkv, d) // 1024, "KiB/token")

bw, kv7 = 2039e9, kv_bytes_per_token(32, 32, 128)
for B in (1, 8, 32):
    print(f"B={B:3d}", round(decode_tokens_per_sec(7e9, kv7, 2048, B, bw)),
          "tok/s", round(B * kv_gib(32, 32, 128, 2048), 1), "GiB")
print("权重上限", round(bw / (7e9 * 2), 1),
      "算力上限", round(312e12 / (2 * 7e9)))
print("32k KV", round(kv_gib(32, 32, 128, 32768), 1), "GiB, 64GiB 并发",
      int(64 / kv_gib(32, 32, 128, 32768)))
```

```text
Llama-2-7B  512 KiB/token
Llama-2-13B 800 KiB/token
Llama-2-70B 320 KiB/token
B=  1 135 tok/s 1.0 GiB
B=  8 722 tok/s 8.0 GiB
B= 32 1349 tok/s 32.0 GiB
权重上限 145.6 算力上限 22286
32k KV 16.0 GiB, 64GiB 并发 4
```

`decode_tokens_per_sec` 的分母是每步的真实读取量：权重一次，加上批内全部序列的 KV。$B=1$ 时结果 135 token/s 与纯权重上界 145.6 相差 7%，差额正是 1 GiB 的 KV 读取；$B=32$ 时吞吐升到 1349 token/s，相对 $B=1$ 提升 10 倍，但每步读取量从 15 GB 涨到 48 GB，其中 KV 占 71%。若此时继续把批加到 64，KV 占比升到 83%，吞吐只再增 17%，且 64 GiB 的 KV 已无法与权重同时放进 80 GB 卡。这组数字给出了容量的双向约束：批越大吞吐越高，但缓存占用线性增长，最终由显存容量而非带宽决定上限。

## 易错点

> [!warning] 以下六条均可在代码或监控中直接检验。
> 1. 量化 scale 的取整与裁剪。用 $s=\max|x|/2^{b-1}$ 而不是 $\max|x|/(2^{b-1}-1)$ 会浪费半个码点；`round` 之后不 `clamp`，超过 $2^{b-1}-1$ 的值在 INT8 上回绕为负数，误差等于整个动态范围。逐通道量化时若沿错误维度取 `max`，得到的是列分组而非行分组，误差统计会看似正常而推理结果全错。
> 2. KV Cache 的 dtype 与字节数。只计算 K 或只计算 V 会使估算减半；用 fp16 的字节数去算 4 bit 缓存会高估 4 倍；分组量化还要加上每组的 scale 与 zero-point 开销，4 bit、组 128 的实际位宽是 4.125 bit 而非 4 bit。把 KV 与权重放在同一张量并行分片假设下也会出错：KV 头数由 $n_{kv}$ 决定，TP 分片后每卡只持有 $n_{kv}/N_{t}$ 个头。
> 3. 批处理的 padding 浪费。静态批处理把序列补齐到批内最长，实际有效计算只占 $\sum S_{i}/(B\max S_{i})$；用补齐后的 token 数计算吞吐会高估 2 倍以上。连续批处理消除的是请求级等待，不消除单条序列内部的填充，也不减少 KV 占用。
> 4. 吞吐与延迟混淆。增大批提高 tokens/s，但每步时间随批增长，TPOT 上升、P95 恶化；用总吞吐的改善推断交互式延迟下降是方向性错误。反过来，把批设为 1 能压低 TPOT，但 GPU 利用率不足 1%，单位请求成本最高。
> 5. 在算力受限区间套用投机解码公式。第 9 节的 $c$ 与"验证 $\gamma+1$ 个位置约等于 1 步"只在带宽受限、批很小时成立；大批量服务中验证成本按 FLOP 线性增长，按公式估出的 2 至 3 倍加速不会出现，反而挤占算力。
> 6. 校准集与线上分布不一致。用通用语料估计激活的动态范围，而线上输入含长数字串、代码或特殊符号时，激活峰值超出校准范围，量化后出现截断，表现为特定输入类型的准确率骤降而平均指标正常。

## 关联笔记

- 前置 [[KV缓存]]：缓存的结构、每 token 字节数公式与增长规律在该篇推导，本篇第 3 节直接引用其结论并加入量化维度。
- 前置 [[分组查询注意力GQA]]：$n_{kv}<n_{h}$ 是压缩 KV 的结构性手段，与本篇的 KV 量化正交，两者可叠加。
- 后续 [[分布式训练与部署]]：单卡显存与带宽受限之后，切分权重、张量并行服务与批调度在该篇展开。
- 后续 [[成本-延迟-质量权衡]]：本篇给出的 TTFT、TPOT 与字节数是该篇成本函数与 SLO 的输入变量。
- 对照 [[自回归生成与采样]]：采样策略改变输出分布与长度，投机解码在不改变分布的前提下改变计算组织，两者容易混淆。

## 达标检测

- [ ] 写出预填充与解码的 FLOP 表达式，并代入 $P=7\times10^{9}$、$S=4096$ 计算注意力占比。
- [ ] 用 $P_{\text{peak}}$ 与 $BW$ 计算 A100 与 H100 的拐点算术强度，并判断 $B=1$、$S=2048$ 的解码属于哪一侧。
- [ ] 手算 Llama-2-70B 在 bf16 与 4 bit 下的每 token KV 字节数，并给出 80 GB 卡上 8k 上下文的并发上限。
- [ ] 说明对称量化中 $2^{b-1}$ 与 $2^{b-1}-1$ 的差别，构造一个不裁剪就回绕的输入并给出反量化误差。
- [ ] 推导 $\mathbb{E}[\text{tokens}]=\frac{1-\alpha^{\gamma+1}}{1-\alpha}$，并解释为何 $\gamma\to\infty$ 时加速比不会无限增长。
- [ ] 解释 PagedAttention 的块表如何把内部碎片限制在 16 个 token 以内，以及前缀共享为什么需要写时复制。
- [ ] 给定 $\alpha=0.7$、$c=0.08$，用代码求使加速比最大的 $\gamma$，并说明该结论在批大小为 64 时是否仍成立。

## 参考来源

- Kwon et al., "Efficient Memory Management for Large Language Model Serving with PagedAttention", 2023, arXiv:2309.06180 —— 对应第 8 节的块表、内部碎片与吞吐对比。
- Frantar et al., "GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers", 2022, arXiv:2210.17323 —— 对应第 4 节逐列误差补偿与海森矩阵推导。
- Lin et al., "AWQ: Activation-aware Weight Quantization for On-Device LLM Compression and Acceleration", 2023, arXiv:2306.00978 —— 对应第 4 节激活感知缩放与显著通道保护。
- Leviathan et al., "Fast Inference from Transformers via Speculative Decoding", 2022, arXiv:2211.17192 —— 对应第 9 节的接受规则、期望产出与加速比公式。
- Dao et al., "FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness", 2022, arXiv:2205.14135 —— 对应第 10 节的 IO 复杂度与分块在线 softmax。
- PyTorch 官方文档，`torch.compile`、`torch.cuda.CUDAGraph` 与 `torch.ao.quantization` 章节 —— 对应第 4 节的伪量化节点与第 11 节的图捕获。
