GPTQ 完全拆解：二阶信息驱动的权重量化，如何把 175B 模型塞进一张 A100

一个旧问题：哪些权重可以动，动了怎么补#

神经网络压缩的经典问题，早在 1989-1992 年就被研究过：如果必须删掉（或量化）某些权重，怎么让损失函数掉得最少？

1990 年 LeCun 等人提出最优脑损伤（OBD，Optimal Brain Damage），用损失函数对权重的二阶导数（Hessian 的对角线）衡量每个权重的重要性，删掉”重要性最低”的权重。但 OBD 有个致命简化：它假设权重之间互不影响，只保留了 Hessian 的对角线。

1992 年，Hassibi 和 Stork 在 NIPS 上发表了 Second order derivatives for network pruning: Optimal Brain Surgeon，提出 OBS：考虑完整的 Hessian 矩阵，并且不光选”删哪个”，还给出”删掉它之后，剩余权重应该怎么调整来最小化损失增量”的闭式解。这个”删一个、补一群”的思想，是后面一切工作的种子。为方便对比，OBD 的对应论文是 Optimal Brain Damage。

2022 年，Frantar 和 Alistarh 在 NeurIPS 2022 发表了 OBQ: Optimal Brain Compression: A framework for accurate post-training quantization and pruning，把 OBS 从剪枝推广到量化：把权重置零（剪枝）本质上是”量化到 0 点”的特例，那 OBS 的整套公式自然可以搬到量化上。OBQ 第一次让”用二阶信息做训练后量化”在小模型（ResNet、BERT 量级）上可行。

GPTQ 就是这个谱系的最新一环：OBD → OBS → OBQ → GPTQ，每一代解决前一代的规模瓶颈。下面先完整推导 OBS/OBQ 的核心公式，因为 GPTQ 的所有改动都是围绕它们做的。

逐层量化：把整模型问题切成单层问题#

训练后量化（PTQ，Post-Training Quantization）的标准流程是逐层量化（layer-wise quantization）：拿一小段校准数据前向跑一遍模型，缓存每一层的输入，然后逐层求解”量化后的权重让这一层输出误差最小”的优化问题。

形式上，设某线性层权重为 $\mathbf{W}$（$d_{\text{row}} \times d_{\text{col}}$），$\mathbf{X}$ 是校准数据在该层的输入（$d_{\text{col}} \times m$，$m$ 个样本），目标是找一个量化权重矩阵 $\widehat{\mathbf{W}}$，使量化前后的层输出尽量一致：

其中量化网格（格点集合）在量化前就固定好，每个权重允许自由移动（这正是与 AdaRound 等”逐权重决定向上还是向下舍入”方法的区别：OBQ 家族不满足于±1 格的选择，而是允许权重在网格之外连续移动，靠补偿来弥补）。

把目标函数按 $\mathbf{W}$ 的行拆开，每行的优化独立：

其中 $\mathbf{w}$ 是 $\mathbf{W}$ 的一行。关键观察：这是一个关于 $\mathbf{w}$ 的二次型，它的 Hessian 是：

注意 $\mathbf{H}$ 只依赖输入 $\mathbf{X}$，与权重 $\mathbf{w}$ 的取值完全无关。这一点是整个故事的地基，后面会反复用到。

OBS 公式：量化一个权重，最优地补偿所有剩余权重#

设当前这一行还有一组未量化的权重集合 $F$。要量化其中的 $w_q$ 到 $\mathrm{quant}(w_q)$。相当于对权重向量施加一个扰动 $\Delta \mathbf{w}$，其中第 $q$ 个分量被锁定为 $\mathrm{quant}(w_q) - w_q$，其余分量自由调整。我们希望其余分量的调整让损失增量最小。

对损失函数 $E(\mathbf{w})$ 在当前位置做二阶泰勒展开。假设模型已训练收敛，梯度 $\mathbf{g} \approx \mathbf{0}$：

约束条件是 $e_q^{\top} \Delta \mathbf{w} = \mathrm{quant}(w_q) - w_q$（$e_q$ 是第 $q$ 个标准单位向量，即只有第 $q$ 个分量被锁死）。用拉格朗日乘子法解这个约束二次规划：

对 $\Delta \mathbf{w}$ 求导置零：$\mathbf{H}_F \Delta \mathbf{w} + \lambda e_q = 0$，即 $\Delta \mathbf{w} = -\lambda \mathbf{H}_F^{-1} e_q$。代回约束：$-\lambda e_q^{\top} \mathbf{H}_F^{-1} e_q = \mathrm{quant}(w_q) - w_q$，解出 $\lambda = (w_q - \mathrm{quant}(w_q)) / [\mathbf{H}_F^{-1}]_{qq}$。于是最优更新为：

其中 $(\mathbf{H}_F^{-1})_{:,q}$ 是逆矩阵的第 $q$ 列，$[\mathbf{H}_F^{-1}]_{qq}$ 是第 $q$ 个对角元。对应地，这个操作带来的损失增量是：

于是”下一个量化谁”的贪心准则一目了然：量化误差平方除以对应的逆对角元，谁最小先量化谁：

直观理解这个公式：分子是”直接舍入的误差平方”，分母是”该权重位置上的逆 Hessian 对角元”。分母越大说明该方向上的误差越难通过其他权重补偿（逆对角线大 ≈ Hessian 该方向曲率小、误差在损失空间里”便宜”），需要优先处理；分母越小说明这个权重的误差很容易被其他权重吸收，可以留到后面。注意 $\mathrm{quant}(w_q)$ 可以落在任意量化网格值上——当网格只有 $\{0\}$ 一个点时，上述公式就退化成剪枝（把权重置 0），这就是 OBQ 统一剪枝与量化的原因。

一个玩具例子：把公式跑一遍#

公式容易让人头晕，用一个小例子走一遍。设一行权重 $\mathbf{w} = [1.2, \; -0.5]$，输入 $\mathbf{X} = \begin{bmatrix} 1.0 & 0.2 \\ 0.5 & -1.0 \end{bmatrix}$（2 个输入维 × 2 个样本）。则：

量化网格取 $\{0, 0.5, 1.0, 1.5\}$（2-bit 量级的演示网格）。先算两个候选的贪心准则值：

• 量化 $w_1 = 1.2 \to 1.0$：误差 $0.2$，准则值 $0.2^2 / 0.5165 = 0.0774$；
• 量化 $w_2 = -0.5 \to 0$：误差 $0.5$，准则值 $0.5^2 / 0.4298 = 0.5817$。

OBS 会先量化 $w_1$（它的误差在损失空间里便宜得多）。量化 $w_1 \to 1.0$ 后，对剩余权重 $w_2$ 的最优补偿是：

即 $w_2$ 从 $-0.5$ 被推到 $-0.452$，用来部分抵消 $w_1$ 被量化造成的输出偏差。两个细节值得注意：第一，补偿的方向由 $\mathbf{H}^{-1}$ 的非对角元决定——如果两个权重互不相关（$\mathbf{H}$ 是对角的），$\mathbf{H}^{-1}$ 非对角元为 0，补偿就传不过去；本例中 $\mathbf{H}$ 非对角元 0.6 说明两个输入特征相关，$w_2$ 才”帮得上忙”。第二，两维玩具里只有一个剩余权重可以分担误差，补偿收益有限（量化后层输出距离从 0.204 降到 0.197）；真实线性层有几千列，误差被摊到所有剩余权重上，且 OBQ 反复迭代”量化一个、补偿一群”，效果才显现——这也是后面实验部分的重点。

OBQ 的复杂度诅咒#

量化一个权重后，$F$ 少了一个元素，下次要用 $\mathbf{H}_{F}^{-1}$。从头重算逆矩阵是 $O(d_{\text{col}}^3)$ 级别，太贵。好在删除一行一列后的逆可以就地更新——这对应一次高斯消元：

（论文原文该式下标有个笔误，此处按正确形式给出。）这是个秩一更新，$O(d_{\text{col}}^2)$ 就能完成。

但 OBQ 整体仍然很慢，慢在贪心顺序：每一行独立运行算法，每量化一个权重都要重新扫描全行找准则值最小的下一个目标，并各自维护自己的 $\mathbf{H}_F^{-1}$（因为各行删列的先后顺序不同，$F$ 不同）。对 $d_{\text{row}} \times d_{\text{col}}$ 的权重矩阵，复杂度是 $O(d_{\text{row}} \cdot d_{\text{col}}^3)$。论文报告，OBQ 量化一个 ResNet-50（2500 万参数）要约 1 个 GPU 小时。线性外推：175B 模型光一层就有数千×数千的矩阵，整体需要几百年。这就是 GPTQ 要解决的问题。

第一步：放弃贪心顺序（Arbitrary Order Insight）#

第一处改造最反直觉：量化顺序根本不重要。论文发现，贪心选择”当前误差最小”的权重固然合理，但和”按任意固定顺序量化”相比，最终误差几乎一样，尤其在大模型的宽层上。论文给出的解释是：贪心顺序确实减少了”单个大误差权重”的数量，但这些大误差权重被拖到流程后期才量化——到那时剩余的、可用来补偿的权重已经很少，补偿能力大打折扣。两个效应互相抵消。

这个观察的工程后果是巨大的。既然顺序可以任意定，就定一个对所有行都相同的顺序（比如按列从左到右）。于是：

1. 任何时刻，所有行的未量化集合 $F$ 都相同；
2. $\mathbf{H}_F = 2\mathbf{X}_F \mathbf{X}_F^{\top}$ 只依赖输入、不依赖权重，所以所有行共享同一个 $\mathbf{H}_F^{-1}$，它只随”删了哪些列”变化；
3. $\mathbf{H}_F^{-1}$ 的更新（上式）每行只需要做 $d_{\text{col}}$ 次（每删一列做一次），而不是 $d_{\text{row}} \cdot d_{\text{col}}$ 次（每量化一个权重做一次）。

复杂度从 $O(d_{\text{row}} \cdot d_{\text{col}}^3)$ 降到 $O(\max\{d_{\text{row}} \cdot d_{\text{col}}^2, \; d_{\text{col}}^3\})$，即快 $\min\{d_{\text{row}}, d_{\text{col}}\}$ 倍——对大规模模型这是几个数量级的差距。

第二步：懒惰批量更新（Lazy Batch-Updates）#

顺序问题解决了，但直接实现仍然慢，瓶颈从计算变成了内存带宽。看更新公式：每次更新要对一个巨大的矩阵 $\mathbf{W}_{:,F}$ 做外积叠加，而每个矩阵元素只摊到几个浮点运算——这种”算得少、读得多”的操作没法喂饱 GPU 的算力，被显存带宽卡死。

论文的关键观察是：第 $j$ 列的舍入决策只受施加在 $j$ 列上的更新影响，施加在更后面列上的更新与当前决策无关。所以更新可以”攒着”：

• 把 $d_{\text{col}}$ 列分成大小为 $B = 128$ 的块；
• 块内部逐列量化，误差只补偿到块内的剩余列（以及 $H^{-1}$ 对应的 $B \times B$ 子块）；
• 一个块全部处理完后，才用批量版公式一次性把误差传播到所有块外的剩余权重。

批量版公式（$Q$ 是刚量化的一组列的下标集合，$\mathbf{H}_{-Q}^{-1}$ 是删去 $Q$ 行 $Q$ 列后的逆矩阵）：

单个权重版的 $\delta = -e / h_{qq} \cdot \mathbf{H}^{-1}_{:,q}$ 是 $Q$ 为单元素时的特例：标量除法变成 $B \times B$ 矩阵求逆（$B=128$ 时开销可忽略），外积变成矩阵乘。论文报告这带来约一个数量级的实际加速，是算法能跑到 175B 规模的关键组件。

第三步：Cholesky 重构（Cholesky Reformulation）#

最后一个问题是数值稳定性。反复用高斯消元式就地更新 $\mathbf{H}^{-1}$ 会累积舍入误差；一旦 $\mathbf{H}_F^{-1}$ 失去正定性（变成 indefinite），补偿更新的方向就会出错，把剩余权重往错误方向推，导致该层量化结果彻底崩溃。论文观察：模型超过几十亿参数时，几乎必然有若干层出这个问题，而且模型越大越容易发生。

小模型时代有个补救：阻尼（dampening）——给 $\mathbf{H}$ 的对角线加一个小常数 $\lambda$（论文固定取对角线平均值的 1%），相当于给优化加一个小的 $\ell_2$ 正则，拉回病态方向。但大模型只靠阻尼不够。

论文注意到一件事：量化 $w_q$ 时，我们真正需要的只是 $\mathbf{H}_{F_q}^{-1}$ 的第 $q$ 行（从对角元开始往右），而不是整个矩阵。而这些行可以一次性、用数值上稳定得多的方式预计算出来——Cholesky 分解。对称正定矩阵有 $\mathbf{H}^{-1} = \mathbf{L}\mathbf{L}^{\top}$（$\mathbf{L}$ 为下三角）。对比高斯消元式更新与 Cholesky 消元：两者每一步做的事情几乎一样，只是 Cholesky 把第 $q$ 行多除了一个 $([\mathbf{H}_{F_q}^{-1}]_{qq})^{1/2}$ 的归一化因子。也就是说，把 $\mathbf{H}^{-1}$ 做一次 Cholesky 分解，得到的三角因子就包含了整个量化过程中需要的全部逆信息，完全不需要反复求逆。论文强调：配合轻度阻尼，用 Cholesky 重构后的算法在千亿参数模型上运行稳定，且成熟的 Cholesky kernel 本身就很快，白赚一笔速度。

完整算法：Algorithm 1 逐行解读#

把三步合起来，就是论文的 Algorithm 1。这里给出与原文一致的伪代码：

1
输入：权重矩阵 W（d_row × d_col），
2
     H^{-1} = (2XX^T + λI)^{-1}（由校准输入算出的逆 Hessian），
3
     块大小 B（论文用 128）
4

5
Q ← 0_{d_row × d_col}              # 量化输出矩阵
6
E ← 0_{d_row × B}                  # 块内量化误差暂存
7
H^{-1} ← Cholesky(H^{-1})^T        # 用三角因子替代逆矩阵
8

9
for i = 0, B, 2B, ...:             # 外层循环：逐块处理
10
    for j = i, ..., i+B-1:         # 内层循环：块内逐列量化
11
        Q_{:,j} ← quant(W_{:,j})                      # 1. 量化第 j 列
12
        E_{:,j-i} ← (W_{:,j} - Q_{:,j}) / [H^{-1}]_{jj}  # 2. 列误差除以对角元
13
        W_{:,j:(i+B)} ← W_{:,j:(i+B)} - E_{:,j-i} · H^{-1}_{j,j:(i+B)}
14
            # 3. 把这一列的误差补偿到块内剩余列
15
    W_{:,(i+B):} ← W_{:,(i+B):} - E · H^{-1}_{i:(i+B),(i+B):}
16
        # 4. 块结束后，把所有块内误差一次性补偿到块外剩余列

逐行解释：

1. 第 1 步把第 $j$ 列直接舍入到网格（quant 对每个元素独立作用）。注意此时 $\mathbf{W}$ 的第 $j$ 列已经被前面步骤的补偿更新过，量化的是”被修正过的权重”。
2. 第 2 步计算列量化误差向量，除以 $[\mathbf{H}^{-1}]_{jj}$——这正是 OBS 公式 $\delta = -e / h_{qq} \cdot (\mathbf{H}^{-1})_{:,q}$ 中”标量部分”的负值（符号在下一步的外积里处理）。$[\mathbf{H}^{-1}]_{jj}$ 此时从 Cholesky 因子的对角元读取。
3. 第 3 步是块内的误差补偿：把第 $j$ 列的误差按 $\mathbf{H}^{-1}$ 的第 $j$ 行权重分摊给块内还没量化的列（$j+1$ 到 $i+B-1$）。外积更新，每列只动 $O(d_{\text{row}})$。
4. 第 4 步是懒惰批量更新的收尾：整个 $B=128$ 列块量化完成后，把暂存在 $\mathbf{E}$ 里的全部误差一次性外推给块外的所有列。矩阵乘形式，GPU 友好。

内层循环结束后，$Q$ 里存的就是量化后的权重；$W$ 本身被原地改成了”补偿后的残差”，块外列会在后续块中被继续量化——这正是”整个矩阵只被读几轮”的懒惰设计。

论文还贴了一个小图（论文 Figure 2）说明分块流程：加粗的连续列是当前正在量化的块，块内白色中间列是正在被量化的那一列，蓝色是等待更新的剩余权重。下面这张图就是论文原图：

全家族 WikiText-2 困惑度#

论文的核心实验是 OPT（125M 到 175B 九个尺寸）和 BLOOM（560M 到 176B 六个尺寸）两大模型家族全部量化到 3-bit 和 4-bit，在 WikiText-2 上测 PPL。下表是 OPT 全家族的结果（论文 Table 3）：

读这张表抓住四个要点：

1. 175B 上 4-bit 几乎无损：GPTQ 8.37 vs FP16 8.34，只涨 0.03；而 RTN 掉 2.2 个点（10.54），比小 10 倍的 FP16 13B 模型（10.13）还差。
2. 3-bit 时 RTN 全线崩溃：RTN 3-bit 在大多数模型上 PPL 破千甚至破万（1300 到 1.6e4），基本不可用；GPTQ 3-bit 在 175B 上仍有 8.68。
3. 模型越大越好量化：从 125M 到 175B，GPTQ 相对 RTN 的优势单调扩大。这是论文强调的”好消息”——压缩最必要的地方（大模型）恰好是最容易压的地方。唯一的例外是 OPT-66B（3-bit 掉到 14.16），论文归因于该模型的早期层有大量死亡单元（dead units）。
4. BLOOM 家族模式相同：BLOOM-176B 上 GPTQ 4-bit 8.21 vs FP16 8.11，3-bit 8.64；只是方法间差距普遍更小——BLOOM 整体更好量化。

论文 Figure 1 用曲线图直观展示了”模型越大、量化损失越小”的趋势（左：OPT 全家族 4-bit；右：BLOOM 全家族 3-bit，与 FP16 基线和 RTN 对比）：

175B 双雄：四项任务全景#

论文对 OPT-175B 和 BLOOM-176B 做了最详细的评估（WikiText-2、PTB、C4 三个困惑度任务 + LAMBADA 零样本任务，论文 Table 5）：

一个有意思的现象：LAMBADA 上 4-bit 的 GPTQ 甚至超过了 FP16 基线（75.59 → 76.80）。论文的解释是 LAMBADA 这类任务对”常见 token 的预测”更敏感，而量化相当于给权重施加了一个轻微的正则化，平滑了某些过拟合的权重——量化偶尔当正则用，这在剪枝文献里也不是新鲜事（“pruning as regularization”）。注意 3-bit 下 RTN 在 LAMBADA 上直接得 0 分，而 GPTQ 还能保持 76 分。

零样本任务与分组效果#

论文 Figure 3 把 OPT 和 BLOOM 各模型量化后在 LAMBADA 上的准确率画成条形图：4-bit 时即使是 RTN 也表现尚可，3-bit 时 RTN 全面崩溃而 GPTQ 保持稳定：

分组在中等模型上的效果用 Figure 4 展示（OPT 中等型号 4-bit，对比 g128/g64/g32）：分组越细（g 越小），PPL 越接近 FP16：

极限量化：2-bit 与三值#

论文还测了极端低位。把最大的两个模型压到 2-bit（每组一个 FP16 scale 和一个 2-bit zero-point），WikiText-2 PPL：

g128 时只涨 1.2-1.4 个点，g32 时只涨 0.6-0.7——2.6 bit 的 GPTQ 已经比无分组的 3-bit 更好。把分组继续缩到 g8，还可以做三值量化（网格 {-1, 0, +1}）：OPT-175B 上 PPL 9.20，只比 FP16 多不到 1 个点。论文顺便提到，这种三值模式在 FPGA 等自定义硬件上尤其有实现价值——这大概是最早把”GPTQ 式量化与 FPGA 存储”联系起来的表述之一。

小模型上的公平对比#

在 ResNet-18/50（视觉 PTQ 标准基准）上，GPTQ 与 AdaRound、BRECQ、OBQ 对比：4-bit 打平（RN50：GPTQ 75.71 vs OBQ 75.72 vs AdaRound 75.84），3-bit 略逊于最准的方法（GPTQ 74.87 vs OBQ 75.24），但大幅快于 AdaQuant 这类可比的快速方法，且耗时从 OBQ 的约 1 小时降到不到 1 分钟。在 BERT-base 与 OPT-125M 上对比完整贪心的 OBQ：4-bit 两者相当，3-bit GPTQ 反而略好（论文猜测是 OBQ 的早停离群舍入等启发式在非视觉模型上需要调参）。