量化与算子

解码受限于内存：每生成一个词元，要有多少字节的权重和缓存穿过总线，又要有多少字节的注意力中间结果被写出再读回。回应这道约束有两个手段。量化把权重或激活表示得更小，让每个词元搬动更少字节。融合算子把注意力中间结果留在高带宽内存之外，让那些字节一开始就不被写出。GPTQ、AWQ 与 SmoothQuant 对离群值各有处理方式；INT4、FP8 与 GGUF 对应不同部署目标；FlashAttention 则说明 IO 感知算子如何改写成本模型。因此，在 vLLM、SGLang 与 TensorRT-LLM 之间选择，也是在选择引擎事先已经优化的是哪一类瓶颈。

内存带宽瓶颈

一个 FP16 权重要两个字节。于是一个七百亿参数的模型，在服务第一个词元之前就已经是一百四十吉字节，单个加速器已经装不下。第 31 章 的服务问题与 第 32 章 的调度，都从这个事实出发：容量花在了静态的权重占用和不断增长的键值缓存上，剩下的部分界定了批大小。

更深的麻烦在带宽，而不只是容量。解码一次只发出一个词元，所以每一步都要读完整套权重，才产出一列激活。算术强度很低，加速器的计算单元空转，实际耗时由字节从高带宽内存搬运得多快决定，而不是由它们相乘得多快决定。第 33 章 从算法一侧处理这一点，让每一趟做更多有用功。本章从系统底层处理它，让每个字节承载更少，也搬动更少的字节。

注意力也遇到同一种内存流量问题。朴素计算会形成完整的 $n \times n$ 分数矩阵，写入内存，读回来施加 softmax，再写一次，再读一次来给值加权。对一条长序列，这个矩阵比输入大得多，算子的时间花在内存流量上，而不是花在真正起作用的矩阵乘上。第 8 章 的架构让注意力居于核心，第 35 章 又把序列长度推高，于是搬动这些中间结果的代价，比模型本身的代价涨得更快。

两个手段回应的是同一个瓶颈。第一个把每个数变小，让必须搬动的字节更少。第二个避免写出那些只会被读回的中间结果。下文依次展开这两个手段，再说明服务情形如何在二者之间挑选，以及上面一层的一项评估如何给整笔交易定价。

手段一：把每个字节变小

量化把一个高精度张量映射到一小组量级上，存下这些量级，再加一个 scale。对整数量化，规则就是一个 scale 加一次取整，

$$\hat{w} = s \cdot \mathrm{round}\!\left(\frac{w}{s}\right), \qquad s = \frac{\max |w|}{2^{b_{\text{bits}}-1} - 1},$$

其中 $w$ 是原始权重，$\hat{w}$ 是量化后再还原的近似值，$b_{\text{bits}}$ 是位宽，$s$ 是把这一块里绝对值最大的权重映射到 $b_{\text{bits}}$ 位有符号整数最大值的尺子。这个式子的直觉是：真正存下的是一个小整数网格，以及把网格点还原成近似权重的 scale。于是一块权重变成 $b_{\text{bits}}$ 位整数加一个浮点 scale。$s$ 的粒度是第一条设计维度：每张量一个 scale，存起来最省，但对分布散开处理得最差；每个输出通道、或每一小组权重一个 scale，会多花一点元数据，却能找回大部分精度。浮点量化在这个小预算里保留符号、指数与尾数，而不是一个均匀网格，这用零附近的一些精度换来动态范围，而且硬件能原生地对这个小格式做乘法。

为何每张量 INT8 会崩：离群值

量化之所以不简单，根源在离群值。权重是模型的固定参数，分布很规整，量化后误差较小。激活，也就是模型运行时在网络里流动的中间值，在一个训练好的 transformer 里则不然：少数通道携带的数值比其余的大上若干数量级，而为覆盖它们选出的那个单一每张量 scale，会把其余部分的精度全部丢掉。从视觉模型沿用过来的朴素每张量 INT8 之所以会在大型 transformer 上崩溃，正是因为规模一旦越过某个点，激活离群值就会涌现出来。每一种严肃的方法，都是对离群值的一种不同回答。图 34.1 画出了这个问题的几何形状：单一的每张量 scale 必须覆盖最大的那个离群通道，这把整数网格变得极粗，规整的主体部分于是只剩屈指可数的几个量级。

在一个分布平稳的向量上跑一遍本章的量化规则，再放入一个离群值，看 scale 如何一路伸展，直到主体部分的误差爆炸。

import numpy as np

def quantize(w, bits=4):
    s = np.max(np.abs(w)) / (2 ** (bits - 1) - 1)
    return s * np.round(w / s), s

rng = np.random.default_rng(0)
bulk = rng.normal(0, 1, 64)        # 规矩的通道
clean = bulk.copy()
spiked = bulk.copy()
spiked[0] = 60.0                   # 一个涌现的离群通道

for name, w in [("no outlier", clean), ("one outlier", spiked)]:
    q, s = quantize(w, bits=4)
    err = np.abs(q[1:] - w[1:]).mean()   # 仅主体部分的误差
    print(f"{name:12s} scale={s:6.2f}  bulk mean abs error={err:.3f}")

对离群值的三种回答

GPTQ、AWQ 与 SmoothQuant 从三个不同角度处理离群值，而各自选的角度，正好决定了它们的长处与限度。

• GPTQ 只量化权重，一次一层，把它当作一个重建问题来做。它用近似的二阶信息，也就是该层输出误差的 Hessian，一种衡量该误差对每个权重有多敏感的量，逐列量化权重，同时更新尚未量化的全精度权重，以吸收刚刚引入的误差 (Frantar et al. 2022)。这把位宽推到每权重三到四位，质量几乎无损，而且完全不碰激活。
• AWQ 同样只量化权重，但起点是这样一个观察：并非所有权重都同等要紧。保护住大约最重要的那百分之一的显著权重通道，便能去掉大部分误差；识别它们靠的是观察激活量级，而不是观察权重。AWQ 把这种保护折叠进一个由搜索找到的每通道缩放里，不做反向传播、不做重建，因此不会过拟合那个小型校准集 (Lin et al. 2023)。
• SmoothQuant 瞄准的是更难的情形，即激活也被量化。它施加一个数学上等价的变换，把激活除以一个每通道因子，再把权重乘以同一个因子，从而把难度从尖刺的激活迁出，迁进平滑的权重 (Xiao et al. 2022)。经此平滑之后，两者都可以取到 INT8，这就为整层解锁了整数矩阵乘，而不只是整数存储。

组织这些选择的两条维度

最后这条区分，就是第二条设计维度：只量化权重，对比量化权重加激活。只量化权重（GPTQ、AWQ）缩小占用，也缩小解码必须读取的字节，这正对带宽受限的解码情形。它本身并不加速大批次预填充里那些受计算约束的矩阵乘，因为激活仍是高精度，权重在相乘之前已经被反量化。量化权重加激活（SmoothQuant、FP8）让矩阵乘本身在小格式下运行，这才是计算而非带宽成为瓶颈时所需要的。

除了权重与激活，还有第三个可量化的张量：缓存本身。缓存下来的键与值，就是留在原地的激活，因此带着同样的离群值与粒度问题；把它们存成 FP8（vLLM 里是 kv_cache_dtype="fp8"，TensorRT-LLM 与 SGLang 暴露同样的选项），能把每词元的缓存字节大致减半。这一个设置同时松动了前文点名的那两条约束：它让 第 32 章 里可接纳的批翻倍，也削减解码每步必须流式读取的字节，代价是一份不大、且因工作负载而异的精度损失。

这些格式就是上述方法最终落到的表示方式。INT8 与 INT4 是带一个 scale 的均匀整数网格，便宜，支持也好。FP8 有两种由 NVIDIA、Arm 与 Intel 联合规定的编码，E4M3 尾数更多以求精度，E5M2 指数更多以求范围，在近期硬件上原生支持，因此能加速乘法本身 (Micikevicius et al. 2022)。FP8 再往下是块级缩放的 FP4，这是 2025 至 2026 年的一步：OCP 的微缩放（MX）格式给每一小块元素配一个共享 scale，MXFP4 让 32 个四位浮点共用一个二的幂次 scale (Rouhani and others 2023)，NVIDIA 的 NVFP4 则把块收紧到 16 个元素，配 FP8 scale 外加一个每张量的 FP32 scale (NVIDIA 2025)。块级 scale 仍是对离群值的回答，只是这次折进了格式本身；Blackwell 的张量核原生执行 FP4 矩阵乘，于是四位的权重加激活推理成了一条硬件路径，而不只是一种存储技巧，已发布的 gpt-oss 权重就以 MXFP4 交付。GGUF 不是一种数值格式，而是一个容器：它是 llama.cpp 生态的文件标准，把权重以分块的「k-quant」方案连同全部元数据一起打包，于是一个量化模型就是一个可移植文件，在 CPU 和 Apple silicon 上可以像在 GPU 上一样部署 (llama.cpp project 2023)。

手段二：不再搬动矩阵

融合算子回应的是内存流量这一半。FlashAttention 算的是精确的注意力，却从不物化分数矩阵。它把查询、键、值矩阵切成能装进快速片上 静态随机存取存储器（SRAM） 的块，并在线计算 softmax：每来一个键块，它就维护一个运行中的最大值和一个运行中的归一化因子，重新缩放部分输出，使最终结果等于完整的 softmax，而完整矩阵从未存在过 (Dao et al. 2022)。

$$m_i = \max(m_{i-1}, \tilde{m}_i), \qquad \ell_i = e^{m_{i-1}-m_i}\,\ell_{i-1} + e^{\tilde{m}_i - m_i}\,\tilde{\ell}_i$$

其中 $m_i$ 是处理到第 $i$ 个块为止的全局最大 logit，$\tilde{m}_i$ 是当前块的最大值，$\ell_i$ 是随这个最大值重新标定后的归一化因子。第二个递推式做的事，是在最大值变大时把旧的指数和按比例缩小，再把当前块的指数和加进来。这样一来，softmax 的数值稳定性和完整矩阵计算完全一致，但输出在成为最终结果之前从不离开 SRAM，$n \times n$ 矩阵从不触及高带宽内存，反向传播则即时重算各块，而不是把它们存下来。这就是该算子做的核心取舍：花额外的算术来避免内存流量。这恰好是对的取舍，因为注意力本就受内存约束。图 34.3 对比了两条数据路径：朴素算子把完整的分数矩阵停在高带宽内存里，而融合算子把每一个中间结果都留在片上 SRAM 内，只让最终输出返回。

选择路径

两个手段最终合成一个选择路径。引擎正在对抗的瓶颈挑出量化方案，融合注意力算子随后位于所选路径之下，如 图 34.4 所示。

从瓶颈判断场景，是本章的实践核心。带宽受限的解码偏向只量化权重的 GPTQ 或 AWQ；计算受限的预填充、或吞吐优先的部署，偏向 FP8 或 SmoothQuant，好让矩阵乘在小格式下跑；CPU 和 Apple silicon 目标偏向 GGUF k-quant 以求可移植；NVIDIA 生产栈则通常选择 TensorRT-LLM，把算子融合并编译到硬件上。

引擎如何整合这些选择

两个手段都经过一段短而清晰的历史才走到今天的形态，而服务引擎正是两条轨道最终汇合的地方。

在量化一侧，故事由离群值驱动。第一波修补把离群值隔离在更高精度里，再量化其余部分。GPTQ（2022）随后表明，细致的二阶权重重建能到三到四位而损失可忽略，让只量化权重的低位服务变得可行 (Frantar et al. 2022)。SmoothQuant（2022）从激活一侧入手，把难度迁进权重，从而实现完整的 INT8，据报告有约一倍半的加速、内存大致减半 (Xiao et al. 2022)。AWQ（2023）围绕显著性与每通道缩放重新构想了只量化权重的做法，据报告相对 FP16 基线有超过三倍的加速，同时避开了重建的过拟合风险 (Lin et al. 2023)。格式的前沿同时在移动，权重一侧从 FP16 到 INT8 到 INT4，在硬件让小浮点原生之后转向 FP8 (Micikevicius et al. 2022)，又在 Blackwell 把更小的浮点也变成原生之后，走到块级缩放的 FP4 (NVIDIA 2025)。

算子沿一条独立的轨道演化，瞄准的是同一个瓶颈。FlashAttention 确立了 IO 感知、绝不物化的设计 (Dao et al. 2022)。FlashAttention-2 重新平衡了工作量，沿序列维度并行化，并减少非矩阵乘运算，把利用率推得更高 (Dao 2023)。FlashAttention-3 专门瞄准 Hopper 代，重叠异步的张量核与内存引擎，并加入低精度 FP8 路径，于是算子和量化的故事在同一硬件上收敛 (Shah et al. 2024)。FlashAttention-4 把这个模式延续到 Blackwell 上，而这一代的变化是方法论上的，而不是又一个新的内存层次思想：内核用嵌入 Python 的 DSL 写成，并与 softmax 算法协同设计，用软件模拟指数运算，只在运行中的最大值真正变动时才重新缩放 (Zadouri et al. 2026)。

引擎把这些进展组织成系统。FasterTransformer 是早期手工优化的基线。vLLM 把分页的键值缓存管理摆在核心，像操作系统的虚拟内存那样对待缓存内存以削减碎片，再把它与量化权重和 FlashAttention 风格的算子配在一起 (Kwon et al. 2023)。SGLang 加入 RadixAttention，在请求之间复用共享前缀，这对后续章节的结构化和智能体工作负载很重要 (Zheng et al. 2023)。TensorRT-LLM 是 NVIDIA 的编译驱动引擎，为自家硬件融合算子、选择低精度路径，以一个开放仓库而非一篇论文的形式分发 (NVIDIA 2023)。

引擎是把这些机制整合起来，而不是重新发明它们。vLLM 在其分页缓存之上把量化暴露为一个服务选项（LLM，vllm/entrypoints/llm.py），并把注意力派发给一个 FlashAttention 后端；SGLang 在其上叠加前缀复用（RadixCache，python/sglang/srt/mem_cache/radix_cache.py）；TensorRT-LLM 把一个模型定义编译成面向目标 GPU 的融合、低精度引擎（github.com/NVIDIA/TensorRT-LLM）。共同的模式是一致的：把权重校准或转换一次，成为一个量化工件，再把它加载进一个已经拥有融合注意力算子和缓存管理器的引擎，然后服务。

每个手段的代价

本章里的每一个选择都用一种资源换取另一种，而正确的点取决于服务情形，不存在某个普适的最优。

• 只量化权重，对比量化权重加激活。 只量化权重是带宽受限解码的正确工具：它缩小占用，也缩小每词元读取的字节，而矩阵乘在反量化之后仍在更高精度下运行。它对计算受限的预填充帮助甚微。连激活也量化，用 SmoothQuant 或 FP8，让矩阵乘在小格式下运行，帮的是计算受限的情形，代价是要正面迎战激活离群值。
• 粒度，对比开销。 更细的 scale，每通道或每一小组，能找回每张量缩放丢掉的精度，但每一块都带自己的 scale，每一次矩阵乘都得付一步反量化。更粗的更快更小，更细的更准。拐点取决于张量数值散开的程度。
• 精度，对比能力。 更低的位宽总会减小占用、通常会提高吞吐，但它会扰动模型的输出。这个扰动的代价有多大，取决于测量的是什么，这正是下面这个下层约束框的主题。
• 算子算术，对比内存流量。 FlashAttention 在反向传播里重算、做额外的重新缩放，而不存储分数矩阵。这之所以是净胜，只因为注意力本就受内存约束；同样的重算放到一个计算受限的算子上，就是浪费。

评估这一关

最后那条权衡，精度对比能力，不会在本章之内了结。它在上面一层、在评估处结清，而把量化模型当作一次模型变更来对待的纪律，正是证明那份节省可靠的条件。图 34.5 概括了这项顾虑：随着位宽下降，一个聚合指标可以几乎保持平坦，而某项特定能力退化得更快，两者之间的差距，正是单个困惑度数字（一个衡量模型对留出文本预测得有多好的平均分数，越低越好）不会报告的代价。

运维上的告诫，正是上面那条下层约束点名的。一个量化工件生产起来很便宜，也容易被误当作无代价。占用的节省是真实而即时的；能力的问题则要等到 第 47 章 的评估对量化权重重跑、而非对原始权重重跑，才有答案。让这件事站得住的纪律，是把每一份量化配方都当作一次受同样测量约束的模型变更，并把格式、位宽与粒度连同分数一并记录下来，使这笔交易可审计。

延伸阅读