第 20 章 量化与压缩

上一章说清了一件事：现代推理的瓶颈多半不在算力，而在把数据搬来搬去。量化就是直接冲着"把数据变小"去的手段——同时也顺带把算力换成了更便宜的那种。

学习目标

读完本章，你应当能够：

1. 说出 FP32、TF32、FP16、BF16、FP8、INT8、INT4 的位布局、动态范围与典型用途，并解释 BF16 与 FP16 的本质区别。
2. 从"让最大幅值恰好落满 int8 范围"这一目标出发，推导线性量化的 s = max(|r_min|, |r_max|)/(2^(n−1) − 1)。
3. 辨析对称量化与非对称量化，解释 zero-point 的作用，以及权重与激活为何偏好不同的方案。
4. 推导缩放因子拆成 s = a/2^b 之后的乘法与加法公式，说明为什么可以退化成移位与加法，并论证"最大可行 b“的单调性。
5. 分析量化误差的三个来源（舍入、截断、离群值），说出 PTQ 与 QAT 的流程差异、校准集的作用以及直通估计器（STE）的必要性。
6. 说明量化推理中反量化的时机，以及为什么 int8×int8 必须用 int32 累加器。
7. 复现全整型量化矩阵乘的完整规则，包括 half-up 舍入与 b 的搜索。

前置知识检查

20.1 数值格式谱系

20.1.1 从位布局理解一个格式

一个浮点数由三段构成：符号位 S、指数位 E、尾数位 M。总位宽 = 1 + E + M。它表达的值是：

x = (−1)^S × 1.M₂ × 2^(e − bias)，其中 e 是 E 位的无符号读数，bias 是固定的偏移量。

三段的分工决定了格式的性格：

• 指数位宽决定动态范围：能表示的最大量级约为 2^(2^E − 1 − bias)，相邻两个可表示数的间距也随指数增长。
• 尾数位宽决定精度：在同一个二进制数量级内，尾数提供了 2^M 个等分点，因此相对精度约为 2^(−M)。

这两者不可兼得——总位宽固定时，给指数多一位，尾数就少一位。

20.1.2 定点的特殊性

INT8、INT4 不是浮点：它们没有指数，只有一组等间距的整数。因此一个整数本身没有物理含义，必须配一个缩放因子（scale）才能还原成真实值。这就是 20.2 要建立的框架。

20.2 线性量化数学

20.2.1 三个基本公式

线性量化（linear quantization）把连续的实数 r 映射成 n 位整数 q：

1
2
3

量化：    q = round( r / s )
反量化：  r ≈ s × q
缩放因子： s = max(|r_min|, |r_max|) / (2^(n−1) − 1)

其中 s 叫缩放因子（scale）。round 通常取四舍五入。

20.2.2 为什么分母是 2^(n−1) − 1

先看 n 位有符号整数能表示什么：补码下范围是 [−2^(n−1), 2^(n−1) − 1]。例如 n = 8 时是 [−128, 127]。

负半轴有 128 个值，正半轴只有 127 个——这个不对称不是笔误，而是补码的必然结果：0 占了正半轴的一个位置，所以"最负"比"最正"多一个。

现在设 m = max(|r_min|, |r_max|) 是待量化张量中绝对值最大的元素。我们要让这个最大幅值恰好落在整数范围的边界上（既不留空、也不越界）。设它落在正边界：

m / s = 2^(n−1) − 1 = 127

解出

s = m / (2^(n−1) − 1)

这一步是整个公式的关键。逐一确认它同时满足三个要求：

1. 不越界：任何 |r| ≤ m，于是 |r/s| ≤ m/s = 127，取整后不超过 127 ≤ 2^(n−1) − 1 ✓
2. 不浪费：存在一个元素（那个绝对值最大的）取整后正好是 ±127，幅值被填满 ✓
3. 均匀：所有元素共用同一个 s，相邻可表示值间距恒为 s ✓

那为什么不用 2^(n−1) = 128 做分母？因为 128 在 int8 里表示不出来（int8 的正边界是 127）。若强行用 128，那个最大元素会取整到 128 而溢出，于是必须 clip——但 clip 意味着信息永久丢失，而且这个元素恰好是最重要的那个。用 127 则既填满又安全。

20.2.3 量化误差的界

由取整的定义，误差满足

|r − s·q| = |r − s·round(r/s)| ≤ s/2

即最大绝对误差是半个量化步长。相对误差则是 ≤ s/(2|r|)，元素越小相对误差越大——这是低精度量化中"小值被噪声淹没"的根源，也是后面要引入逐通道与分组粒度的直接原因。

20.3 对称量化、非对称量化与粒度

20.3.1 对称 vs 非对称

非对称量化多了一个 zero-point（零点）z，它的作用是：让真实值 0 精确地映射到某个整数（具体地，映射到 z）。反量化式变成 r ≈ s·(q − z)。

为什么零点的存在很重要：在神经网络里 0 是特殊值——padding、ReLU 的输出、掩码位置全都需要精确的 0。若用对称量化去表示一个全部为正的区间（例如 ReLU 之后激活值恒 ≥ 0），那么有一半的整数码点（负半轴）被完全浪费，有效精度直接减半。非对称量化把 [r_min, r_max] 拉伸到整个整数范围，避开这个浪费。

为什么权重常用对称、激活常用非对称：

• 权重分布近似以 0 为中心，max(|r_min|,|r_max|) 的两侧大致相等，对称量化几乎不浪费——而且对称量化下 z = 0，s·(q−z) 简化为 s·q，整数点积后只需乘一个缩放因子，硬件实现简单、无额外偏移项。
• 激活分布明显偏移（ReLU 后全正，或存在单侧离群值），若强行对称，一半码点闲置；更糟的是，max(|r_min|,|r_max|) 会被一侧的极端值支配，把 s 撑得很大，导致另一侧精度崩掉。

20.3.2 量化粒度

以权重矩阵 W ∈ R^{C_out × C_in} 为例：逐张量只有一个 s，只要C_out 中某一行的幅值特别大，其他所有行都跟着用这个被撑大的 s；逐通道给每一行一个 s，各行独立；逐分组则在行内再切段，进一步隔离离群值。

这是**“隔离离群值的影响范围”**这一思路的连续谱：粒度越细，被一个极端值污染的邻居越少，精度越高，代价是元数据（scale 表）变大、内核实现更复杂。INT4 权重几乎总是配逐分组，因为 4 位的码点太少，容不下任何浪费。

20.4 把缩放因子拆成 a / 2^b

20.4.1 动机

s 是个实数。若把它直接拿去乘整数，还是得做浮点乘法，在只有整数运算单元的硬件（DSP、NPU、端侧 MCU）上就跑不起来。解决办法是把这个实数也表示成"整数 ÷ 2 的幂"：

s = a / 2^b，其中 a 是整数、b 是非负整数。

2^b 是 2 的幂，因此"除以 2^b“或"乘以 2^b“在二进制里就是右移 / 左移——零成本、无精度损失、无浮点单元参与。这就是全部动机。

20.4.2 乘法为什么能变成"a 相乘、b 相加”

设两个实数分别是 f₁ = a₁ / 2^(b₁)、f₂ = a₂ / 2^(b₂)。由指数的乘法法则 2^(b₁)·2^(b₂) = 2^(b₁+b₂)：

1
2
3

f₁ × f₂ = (a₁ / 2^b₁) × (a₂ / 2^b₂)
        = (a₁ · a₂) / (2^b₁ · 2^b₂)
        = (a₁ · a₂) / 2^(b₁ + b₂)

结论：

• 整数部分：a₁ · a₂——一次纯整数乘法；
• 指数部分：b₁ + b₂——一次整数加法；
• 整体：一次整数乘法 + 一次移位，没有任何浮点运算。

20.4.3 加法为什么能变成"对齐后相加”

加法不能直接移项，因为两个分数的分母不同，必须先通分。统一到较大的那个分母 2^max(b₁,b₂)。设 b₂ ≥ b₁：

1
2
3
4
5
6

f₁ = a₁ / 2^b₁
   = (a₁ · 2^(b₂−b₁)) / 2^(b₂)      ← 分子分母同乘 2^(b₂−b₁)，通分
f₂ = a₂ / 2^b₂

f₁ + f₂ = [ a₁ · 2^(b₂−b₁) + a₂ ] / 2^(b₂)
        = [ (a₁ << (b₂ − b₁)) + a₂ ] / 2^max(b₁,b₂)

写成一般形式：

f₁ + f₂ = ( a₁ << (max(b₁,b₂) − b₁) + a₂ << (max(b₁,b₂) − b₂) ) / 2^max(b₁,b₂)

结论：两次左移 + 一次整数加法 + 一次右移。b 较大的一方不移（移位量为 0），b 较小的一方左移 Δb 位——这正是"把小数点对齐"在二进制里的说法。

20.4.4 为什么 b 越大越好，以及怎么找最大的 b

b 越大，精度越高。 理由：s = a/2^b 中真正的有效数字全在 a 里，而 a 是个位数有限的整数。条件数上看：

s ≈ a / 2^b，当 a 只有 0~127 这 128 个可能取值时，能表示的 s 是离散的。把 s 的绝对值放大 2^b 倍再取整，能保留的有效位就更多。换句话说，b 越大，a 越能"细粒度"地逼近 s·2^b，表示的相对误差越小。

约束是 a ≤ 127（8 位量化下 a 也要能塞进 int8）。于是问题变成：在 a ≤ 127 的前提下，b 能取多大？

给定 s > 0，要求 half_up(s · 2^b) ≤ 127。定义

F(b) = s · 2^b

单调性论证：F(b) 关于 b 严格单调递增（因为 2^b 随 b 递增，而 s > 0）。因此：

• 若 F(b) ≤ 127，则对所有 b' < b 都有 F(b') ≤ 127（可行集合是向下封闭的，形如 {0, 1, …, b*}）；
• 一旦某个 b 使 F(b) > 127，之后不会再退回来。

所以最大可行 b 就是"可行集合的上端点"，从上限（如 30）往下扫，遇到的第一个满足者即是答案。不需要二分，更不需要检查所有 b 的可行性——单调性保证了"第一个可行"就是"最大可行"。

1
2
3
4
5
6

算法：find_b(s)
  for b = B_max down to 0:
      if half_up(s × 2^b) ≤ 127:
          return b        ← 第一个可行者即最大 b
  return 0                ← 兜底：s 异常大时退化为 b = 0
a = half_up(s × 2^b)

注意 half_up 与 round 的区别在这里会直接改变答案（见 20.7 的算例）。

20.5 量化误差分析与离群值治理

20.5.1 误差的三个来源

离群值才是 LLM 量化的主要障碍，也是三条治理思路的靶子：

• per-channel / per-group：缩短短板的影响范围（20.3.2）。
• clipping（截断）：故意把 s 定得比 m/(2^(n−1)−1) 小一点，让最极端的几个值被 clip 掉，换取其余 99.9% 元素的精度。是否划算取决于"被牺牲的元素对最终结果的重要性"——这是 AWQ 的核心洞察：并非所有权重同等重要，激活值大的通道对应的权重更关键，应当受保护而不是被牺牲。
• SmoothQuant：观察到激活难量化、权重好量化，于是在两者之间做一次等价变换——对激活除以逐通道的缩放 diag(s)，对权重乘上它：(X diag(s)^(−1))·(diag(s) W) = XW。数学上完全等价，但把量化难度从激活"迁移"到了权重。这是"不改结果只改数值分布"的典范技巧。

20.5.2 PTQ 与 QAT

校准集的作用：PTQ 需要知道激活的实际分布范围才能定 scale，而这个范围只能通过让真实数据过一遍模型来观测。校准集不必与训练集同分布，但必须覆盖部署时的输入分布——否则 scale 定偏，精度无从谈起。这也解释了为什么"用一批随机噪声校准"是典型的失败做法。

伪量化（fake quant）：QAT 的前向里插入 Q(x) = s·round(x/s) 这种"量化再反量化"的算子。它让前向的数值行为与部署时一致（含量化误差），从而让训练能感知到误差并适应它；输出仍是浮点，可以继续正常前向。

直通估计器（straight-through estimator, STE）：round 的导数几乎处处为 0（阶跃函数），链式法则下梯度会变成全 0，网络无法训练。STE 的做法是反向时直接把 round 当作恒等映射：

1
2

前向： y = s · round(x / s)
反向： ∂y/∂x ≈ 1        ← 忽略 round 的导数，梯度原样穿过

这不是数学上严格的梯度，但工程上极其有效：它给出了一个方向正确的近似梯度信号。可以理解为"告诉优化器：这里量化有点噪声，你照常更新，只是别忘了把权重推向量化格点附近"。

20.6 量化推理：反量化时机与累加位宽

20.6.1 反量化放在哪一步

反量化的位置决定了整个推理的形态：

核心原则：能拖到最后的反量化就不要提前做。 因为一旦反量化，数据就变回 FP16、体积翻倍，前面省下的带宽又还回去了。全整型量化的最优形态是：整数点积在整个求和过程中保持整数，只在最后乘一次 s_A·s_B。

20.6.2 为什么 int8×int8 要用 int32 累加

先算单个乘积的量级：两个 int8 的乘积，最坏情况是 127 × 127 = 16129。

再看累加：K 项求和的最坏情况是 K × 16129。K = 1024 时约 1.65 × 10⁷；K = 4096 时约 6.6 × 10⁷。

对照整数类型的表示范围：

结论：int8×int8 必须用 int32 累加器。 用 int16 会溢出，用 int32 有充足余量（2.1×10⁹ / 16129 ≈ 130000 项）。

真实的量化误差是随机的、可正可负，实际和远小于最坏情况；但硬件设计必须按最坏情况定累加器位宽，否则会是偶发的、极难复现的数值错误。这也解释了 NVIDIA 的 INT8 Tensor Core 为什么规定累加器是 int32——这是被写入指令集语义的约束。

20.7 全整型量化矩阵乘的完整规则

【2026-09-02 编程题 2】 要求输入已量化的 A（m×k）与未量化的 B（k×n，按列给出），输出全整型量化的 C = A×B，每个元素输出三个整数 量化值 a b。

20.7.1 为什么可以全程走整数

把 A 的第 i 行与 B 的第 j 列的每个因子都写成"整数 × 缩放因子"：

A[i][t] = Ā[i][t] · sᴀ_i，B[t][j] = B̄[t][j] · sʙ_j

代入矩阵乘的定义并提取公因子（同一行同一列的缩放因子在整个求和里是常量，可以提到求和号外）：

1
2
3
4
5

C[i][j] = Σ_t A[i][t] · B[t][j]
        = Σ_t ( Ā[i][t] · sᴀ_i ) · ( B̄[t][j] · sʙ_j )
        = ( Σ_t Ā[i][t] · B̄[t][j] ) · sᴀ_i · sʙ_j
          └────────┬────────┘   └────┬────┘
            整数点积              缩放因子之积

于是输出的三段信息各有明确出处：

第二、三行正是 20.4.2 的乘法公式：s = a/2^b 相乘即"a 相乘、b 相加"。题面说明结果无需约简，所以量化值允许超过 127、b 允许超过 30。

20.7.2 对 B 的每一列做量化并拆分

1
2
3
4
5
6

对 B 的第 j 列（k 个浮点数）：
  mx = max( |v| for v in col )          ← 该列的绝对最大值
  s  = mx / 127                          ← 分母 2^(8−1) − 1 = 127
  q  = [ half_up(v / s) for v in col ]   ← 量化值，落在 [−127, 127]
  b  = find_b(s)                         ← 从 30 往下扫第一个可行 b
  a  = half_up(s × 2^b)

B 是按列给出的，所以"读一列立刻量化"最自然——这一点在 IO 层面也是必要的，因为要算 mx 必须先拿到整列。

20.7.3 half-up 舍入：一个会改变全部答案的细节

half-up（逢五进一） 指恰为 .5 时向上取整：round(63.5) = 64、round(64.5) = 65。

而多数语言内置的 round() 用的是银行家舍入（round-half-even）：恰为 .5 时舍入到最近的偶数。于是 round(63.5) = 64（得偶数），但 round(64.5) = 64（而不是 65）、round(2.5) = 2（而不是 3）、round(0.5) = 0。也就是说：凡是恰好落在 .5 上的取值，两种舍入给出的结果可能相差 1。

为什么这个差别会毁掉整道题：a 与 b 都是由 s 经这个函数算出来的，a 差 1、b 差 1，输出的后两个整数全部对不上，而且 b 一变还会牵动 find_b 的返回值。判别与实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import math

QMAX = 127                      # int8 量化幅值上限 = 2^(8-1) - 1


def half_up(x):
    """half-up 四舍五入：63.5 -> 64、64.5 -> 65。
    绝不能用 Python 内置 round()：它是银行家舍入，64.5 会被舍成 64。"""
    return int(math.floor(x + 0.5))


def find_b(s):
    """把缩放因子 s 表示成 a / 2^b。b 越大、a 的有效位越多、表示越精确。
    s * 2^b 关于 b 严格单调递增，越过 127 后不会退回来，
    所以从上限 30 往下扫，第一个可行者就是最大的 b。"""
    for b in range(30, -1, -1):
        if half_up(s * (2.0 ** b)) <= QMAX:
            return b
    return 0                    # 兜底：s 异常大时退化为 b = 0


def quantize_column(col):
    """对一列浮点数做 8 位量化，返回 (量化值列表, a, b)"""
    mx = max(abs(v) for v in col)
    if mx == 0:                 # 全零列必须单独处理，否则 mx/127 = 0 会除零
        return [0] * len(col), 0, 0
    s = mx / QMAX               # 除以 s 后该列最大元素恰好落在 ±127
    q = [half_up(v / s) for v in col]
    b = find_b(s)
    return q, half_up(s * (2.0 ** b)), b


def dot_product(u, v):
    """纯整数点积：量化之后乘加全部在整数上完成，这正是"全整型"的意义"""
    total = 0
    for x, y in zip(u, v):
        total += x * y
    return total

20.7.4 一个可手算的算例

样例中 B 的两列分别是 (1.0, 2.0)（第 0 列）与 (3.0, 4.0)（第 1 列）。逐列走一遍：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

第 0 列 col = [1.0, 2.0]
  mx = 2.0
  s  = 2.0 / 127 ≈ 0.015748
  q  = [ half_up(1.0/0.015748), half_up(2.0/0.015748) ]
     = [ half_up(63.5), half_up(127.0) ] = [64, 127]
  find_b: 从 30 往下扫，找到 s × 2^18 ≈ 4127.6 超限、
          s × 2^12 ≈ 64.5 ≤ 127  ⟹ b = 12
  a  = half_up(s × 2^12) = half_up(64.5) = 65      ← 若用 round() 会得 64
  本例中 (a, b) = (65, 12)

第 1 列 col = [3.0, 4.0]
  mx = 4.0
  s  = 4.0 / 127 ≈ 0.031496
  q  = [ half_up(95.25), half_up(127.0) ] = [95, 127]
  s × 2^11 ≈ 64.5 ⟹ b = 11
  a  = half_up(s × 2^11) = 65                      ← 本例为 (65, 11)

A 两行（题面给出）为：第 0 行量化值 [64, 127]、(a, b) = (65, 12)；第 1 行量化值 [95, 127]、(a, b) = (65, 1)。

现在算 C[0][0]：

1
2
3
4

整数点积 = 64×64 + 127×127 = 4096 + 16129 = 20225
a  = aᴀ_0 × aʙ_0 = 65 × 65 = 4225
b  = bᴀ_0 + bʙ_0 = 12 + 12 = 24
输出 "20225 4225 24"

算 C[1][1]：

1
2
3

整数点积 = 95×95 + 127×127 = 9025 + 16129 = 25154
a  = 65 × 65 = 4225
b  = 1 + 11 = 12

20.7.5 量化对精度与吞吐的实际影响

混合精度量化策略：并非所有层都同样耐受低精度。实践中通常保持高精度的部分包括：

• 第一层与最后一层（直接接触输入输出，误差影响大）；
• LayerNorm / RMSNorm 与 Softmax（数值敏感，且本身访存占比低，量化收益小）；
• 注意力分数计算（softmax 的输入精度直接影响分布形状）；
• KV Cache 可按 FP8/INT8 存储，收益大且精度损失可控。

这与 20.5 的结论一致：量化收益来自矩阵乘，风险来自敏感算子——把收益大的地方压低精度、把风险大的地方保持高精度，就是混合精度的全部内容。

本章小结

自测题

Q1（推导）设某层权重的最大幅值为 m = 3.2，采用 8 位对称量化。求缩放因子 s，并说明当 r = 1.0 时反量化后的误差上界。

Q2（推导）已知 f₁ = 3/2²、f₂ = 5/2³。分别用 20.4 的公式计算 f₁ × f₂ 与 f₁ + f₂，写出每一步的整数操作。

1
2
3

a = a₁ × a₂ = 3 × 5 = 15
b = b₁ + b₂ = 2 + 3 = 5
f₁ × f₂ = 15 / 2⁵ = 15/32 = 0.46875

1
2
3

f₁ = 3/2² = (3 << (3−2)) / 2³ = 6/2³
f₂ = 5/2³ = (5 << (3−3)) / 2³ = 5/2³
和 = (6 + 5) / 2³ = 11/8 = 1.375

Q3（判断）某工程师说：“我们用 round() 做量化，a 和 b 都从 s 算出来，两种舍入最多让结果差 1，不影响正确性。“请评价这个说法。

Q4（计算）一个线性层的权重形状为 4096 × 4096，用 INT8 存储。问：(a) 单次前向读取权重需要多少字节？(b) 若 K = 4096，用 int8 累加会发生什么？(c) 用 int32 的安全余量是多少？

Q5（辨析）某团队用 PTQ 把模型量化到 INT4，用一批 N(0,1) 随机噪声做校准，结果精度大幅下降。请指出问题所在，并给出两条改进方案。

Q6（计算）对一列 [0.5, 2.0] 做 8 位量化并拆成 a/2^b，写出 (q, a, b)。b 的可行上界在哪一步被卡住？

1
2
3
4

mx = 2.0
s  = 2.0 / 127 ≈ 0.0157480
q  = [ half_up(0.5/0.0157480), half_up(2.0/0.0157480) ]
   = [ half_up(31.75), half_up(127.0) ] = [32, 127]

1
2
3

s·2^12 ≈ 64.5008  ≤ 127   ✓
s·2^13 ≈ 129.0016 > 127   ✗     ⟹ b = 12
a = half_up(s·2^12) = half_up(64.5008) = 65

与真题的关联

延伸阅读

• Jacob et al., Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference, CVPR 2018 —— 线性量化与 int32 累加的标准参考文献。
• Dettmers et al., LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale, NeurIPS 2022 —— 首次系统刻画 LLM 激活中的离群特征。
• Frantar et al., GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers, ICLR 2023；Lin et al., AWQ: Activation-aware Weight Quantization, MLSys 2024 —— PTQ 的两条主线。
• Xiao et al., SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models, ICML 2023 —— 激活到权重的难度迁移技巧。
• Micikevicius et al., FP8 Formats for Deep Learning, 2022 —— E4M3 与 E5M2 的设计取舍。
• 第 5 章（IEEE 754 与舍入模式）补充浮点位布局的细节；第 26 章（工程实现纪律）讨论 half-up 与银行家舍入的通用判别方法。