GPTQ：一键量化大模型压缩

可视化演示

量化基础

搬家前，你要把所有纪念品塞进更小的行李箱。没有打包经验的人只会硬压，结果箱壁鼓包、物品受损。量化也是同理：模型原本用 FP16（16bit，占 2 字节）存每个权重，相当于每件物品都套着一个厚盒子；我们想换成 4bit 的小盒子，体积立刻缩小，但直接“硬压”可能把模型精度压坏。

在 AI 部署中，量化就是把网络权重从高精度数值类型转到低精度数值类型。FP16 每个参数占 2 字节，4bit 每个参数只占 0.5 字节。对 70 亿参数的大模型来说，光权重就从约 14GB 降到约 3.5GB，显存压力骤减。代价是数值表示精度下降，需要巧妙压缩才能让损失尽量小。

$$\displaystyle \text{size}_{4\text{bit}} = \frac{4}{16}\times \text{size}_{\text{FP16}} = \frac{1}{4}\,\text{size}_{\text{FP16}}$$

1. 分子 4bit：量化后每个权重只保留 4 个二进制位，能表示 16 种不同数值档位。

$$4\ \text{bit} = 2^4 = 16\ \text{档位}$$

2. 分母 16bit：FP16 用 16 个二进制位，能表示 65536 种数值状态。

$$16\ \text{bit} = 2^{16} = 65536\ \text{档位}$$

3. 结果四分之一：两者相除得到 0.5 字节对 2 字节，所以存储变成原来的 25%。

$$\frac{4}{16} = \frac{1}{4}$$

不过，省下的每一 GB 显存都来自“信息取舍”。我们不追求毫无损失，而是像专业打包师一样，用最小的褶皱换取最大的压缩空间。GPTQ 要解决的问题，就是把这件“压缩行李”做得又快又稳。

GPTQ思想

打包师面对一堆纪念品时，不会随机丢弃一个杯子，而是先判断“如果必须扔掉这个杯子，对整箱物品的平衡影响有多大”。GPTQ 的思想正是来自经典的最优脑手术（OBS）：从网络里“摘掉”不重要的连接，同时调整剩余连接来补偿损失。

GPTQ 把 OBS 的“剪掉某个权重”改成了“把某个权重舍入到低精度档位”。量化不是盲目四舍五入，而是寻找一个量化后的权重向量 \(\mathbf q\)，使得它和原权重 \(\mathbf w\) 之差在误差曲面上的“能量”最小。误差曲面的形状由一个叫 Hessian 的矩阵描述，后面我们会详细展开。

$$\displaystyle \mathbf q^{\star} = \arg\min_{\mathbf q \in \mathcal{Q}} \; \frac{1}{2}(\mathbf q - \mathbf w)^{\top} \mathbf H^{-1} (\mathbf q - \mathbf w)$$

1. argmin：遍历所有可选的量化结果，找出让目标函数最小的那一个。

$$\arg\min_{\mathbf q \in \mathcal{Q}}$$

2. 误差向量：\(\mathbf q - \mathbf w\) 表示量化前后权重差了多少。

$$\boldsymbol{\delta} = \mathbf q - \mathbf w$$

3. Hessian 加权：用 \(\mathbf H^{-1}\) 把误差放到真实误差曲面上衡量，而不是简单看绝对值大小。

$$\boldsymbol{\delta}^{\top} \mathbf H^{-1} \boldsymbol{\delta}$$

所以 GPTQ 的核心思路是：不追求每个权重都四舍五入“看起来最接近”，而是追求整层输出误差最小。打包师的每一个小动作，都要以整箱行李的平衡为准。

二阶信息

打包师为什么总能知道压坏哪个杯子影响最小？因为他手里有一面“重量关系镜”：每件物品移动时，其他物品会受到多大牵连。这面镜子在数学上就是 Hessian 矩阵。

Hessian 是损失函数对权重的二阶导数矩阵。一阶导数告诉你误差朝哪个方向下降，二阶导数告诉你误差曲面在这一点弯曲得有多剧烈。GPTQ 用的 Hessian 不需要反向传播梯度的分母，而是直接由当前层的输入激活值构造：它衡量“如果这个权重变一点，层输出会被放大多少倍”。

$$\displaystyle \mathbf H = 2 \sum_{i=1}^{N} \mathbf x_i \mathbf x_i^{\top}$$

1. 激活向量：每个样本经过层时都会产生一个 \(\mathbf x_i\)，它是这层看到的具体输入。

$$\mathbf x_i \in \mathbb{R}^{d}$$

2. 外积：\(\mathbf x_i \mathbf x_i^{\top}\) 把单个样本的“每个维度与每个维度的相关性”记录成矩阵。

$$\mathbf x_i \mathbf x_i^{\top}$$

3. 累加乘 2：把所有样本的相关性相加，再乘 2，就得到该层权重误差的 Hessian。

$$2\sum_{i=1}^{N} \mathbf x_i \mathbf x_i^{\top}$$

实际计算时，直接求 Hessian 的逆矩阵可能既慢又不稳定，所以 GPTQ 常用 Cholesky 分解等数值工具来稳定求解。对打包师来说，这相当于不需要真的做几百次实验，而是用一张可靠的“关系表”快速推算。

逐层量化

大模型成百上千层，如果把整个模型当一整箱东西来打包，误差会互相纠缠，几乎无法计算。GPTQ 的做法是：一个房间一个房间地打包，也就是逐层量化。

每一层被单独“隔离”出来。我们用一小部分校准数据流过这个层，记录输入激活与输出。量化该层权重时，只让“这个层的输出误差”最小，不直接管其他层。这样的好处是目标明确、计算量可控，也方便工程上分批处理。

$$\displaystyle \mathcal{L}_l = \left\| \mathbf W_l \mathbf X - \widehat{\mathbf W}_l \mathbf X \right\|_F^2$$

1. 原层输出：\(\mathbf W_l \mathbf X\) 是原始权重作用在输入激活上的输出。

$$\mathbf Y_l = \mathbf W_l \mathbf X$$

2. 量化层输出：\(\widehat{\mathbf W}_l \mathbf X\) 是量化后权重计算出的输出。

$$\widehat{\mathbf Y}_l = \widehat{\mathbf W}_l \mathbf X$$

3. 范数平方：把两个输出矩阵逐元素求差、平方、求和，得到该层误差。

$$\left\| \mathbf Y_l - \widehat{\mathbf Y}_l \right\|_F^2$$

逐层隔离让量化过程变成了流水线：第 1 层打包好，再处理第 2 层；每层只需要保留自己的 Hessian，不需要全局反复迭代。打包师可以在每个房间里任意调整，不用担心隔壁房间的箱子被撞翻。

误差补偿

当打包师把一件杯子压扁时，箱子底部会塌下去一块。他不会假装没看见，而是立刻把旁边的衣服往凹陷处推一推。GPTQ 里这个“扶一把”的动作，就是误差补偿。

具体来说，量化某一列的权重时，当前列的舍入误差已经产生了。为了让层输出误差不变大，GPTQ 会更新当前行中尚未被量化的权重列。补偿的大小和方向，由反 Hessian 矩阵决定：误差不是平均分摊，而是沿着“误差曲面最不敏感”的方向分配。

$$\displaystyle \boldsymbol{\delta}_F = \frac{q - w_q}{\left[\mathbf H^{-1}\right]_{qq}} \, \left[\mathbf H^{-1}\right]_{F, q}$$

1. 舍入差：\(q - w_q\) 是量化前后这个权重的变化量，也是“压扁产生的误差”。

$$d = q - w_q$$

2. 分母归一：除以 \(\left[\mathbf H^{-1}\right]_{qq}\)，把误差放在该维度自身的曲率尺度上。

$$\frac{d}{\left[\mathbf H^{-1}\right]_{qq}}$$

3. 方向分配：乘上反 Hessian 的第 \(q\) 列，把误差按相关性扩散到其他未量化权重。

$$\left[\mathbf H^{-1}\right]_{F, q}$$

补偿是逐列扫描完成的：量化完第 1 列，立刻更新后面所有列；等处理第 2 列时，它已经吸收过前面的补偿。打包师的动作环环相扣，最终让整箱行李高度和原来几乎一样。

分组方案

同样的打包师，如果把整层 4096 个权重当作一个大箱子去配重，局部的小起伏就很难照顾到。GPTQ 采用分组方案：把权重列切成若干组，比如每组 128 个权重，每组拥有自己的量化缩放系数和零点偏移。

scale 控制步长，zero 控制零点。每个小组独立管理配重，就像行李箱里用多个收纳隔层，每层都自备卡扣。组越小，适配局部数值分布的能力越强，但需要存储更多额外参数；组太大，又会丢掉局部细节。128 是实践中常用的平衡点。

$$\displaystyle \widehat x = \text{scale} \times \mathrm{round}\left(\frac{x - \text{zero}}{\text{scale}}\right) + \text{zero}$$

1. 缩放系数 scale：决定当前组内一个“档位”代表多大的数值范围。

$$\text{scale} = \frac{\max(x) - \min(x)}{2^{\text{bits}} - 1}$$

2. 零点 zero：把原分布里的某个值映射到 0 档位，用来对齐非对称分布。

$$\text{zero} = 0 - \frac{\min(x)}{\text{scale}}$$

3. 四舍五入 + 还原：\(\mathrm{round}\) 产生整数档位，乘回 scale、加回 zero 就得到反量化值。

$$q = \mathrm{round}\left(\frac{x - \text{zero}}{\text{scale}}\right), \quad \widehat x = \text{scale} \times q + \text{zero}$$

分组是打包师手里的“分隔袋”。它让 4bit 的小档位不至于全局统一、顾此失彼，而是在每个局部区域都有一把合适的“尺子”。

工程实践

掌握了原理，真正上岗时还要懂搬家公司流程。GPTQ 落地时不需要自己从头写反 Hessian 求逆，可以直接使用开源 GPTQ 库，它已经封装好层替换、Hessian 构建和逐列更新逻辑。你只需要准备一个小型校准数据集，让数据流经模型逐层收集激活值。

量化时不能把整个 1750 亿参数全量读进显存再算，而要像搬家一样分批装箱。逐层量化、分批加载权重，可以显著降低显存峰值。量化完成后，一定要在验证集上测困惑度或下游任务指标：如果压缩后精度回落明显，需要调整分组大小、校准数据量或是否启用更多数值优化技巧。

$$\displaystyle \text{GPU}\ \text{memory} \approx \frac{\text{num\_params} \times \text{bits}}{8}$$

1. 参数数量：模型的权重总数，比如 70 亿表示有 \(7\times10^9\) 个参数。

$$\text{num\_params} = 7 \times 10^9$$

2. 比特数：每个参数用 4bit 存储，而不是原来的 16bit。

$$\text{bits} = 4$$

3. 除以 8 换成字节：8 个 bit 等于 1 个 Byte，所以得到显存占用。

$$\frac{7 \times 10^9 \times 4}{8} \approx 3.5\ \text{GB}$$

工程实践像真正的“搬家公司验收”：不仅要把箱子塞进小客车，还要确认物品没碎。GPTQ 省下的显存和加速效果非常可观，但永远要保留最后一道精度验收流程，才能安全上车。

AI 应用场景

Python 演示

import numpy as np def nearest_quant(w, bits=4):    qmax = 2 ** (bits - 1) - 1    scale = np.abs(w).max() / qmax    return np.clip(np.round(w / scale), -qmax, qmax) * scale def gptq_quantize(W, Hinv, bits=4):    Wq = W.astype(float).copy()    rows, cols = W.shape    qmax = 2 ** (bits - 1) - 1    scale = np.abs(W).max(axis=1, keepdims=True) / qmax    for c in range(cols):        q = np.clip(np.round(Wq[:, c] / scale[:, 0]), -qmax, qmax) * scale[:, 0]        d = q - Wq[:, c]        if c + 1 < cols:            compensation = np.outer(d / Hinv[c, c], Hinv[c, c + 1:])            Wq[:, c + 1:] += compensation        Wq[:, c] = q    return Wq np.random.seed(0)rng = np.random.default_rng(0)n_samples, in_dim, out_dim = 128, 16, 8X = rng.standard_normal((n_samples, in_dim))W = rng.standard_normal((out_dim, in_dim))Y = X @ W.T H = X.T @ X + 1e-6 * np.eye(in_dim)Hinv = np.linalg.inv(H) W_round = np.vstack([nearest_quant(row) for row in W])W_gptq = gptq_quantize(W, Hinv, bits=4) err_round = np.mean((Y - X @ W_round.T) ** 2)err_gptq = np.mean((Y - X @ W_gptq.T) ** 2)print(f"round-only MSE: {err_round:.6f}")print(f"GPTQ MSE:       {err_gptq:.6f}")

1. H = X.T @ X + 1e-6 * np.eye(in_dim)用输入激活的协方差构造 Hessian，并加一个小对角项保证数值稳定。
2. Hinv = np.linalg.inv(H)求反 Hessian 矩阵，后面误差补偿的方向全靠它。
3. scale = np.abs(W).max(axis=1, keepdims=True) / qmax每个输出神经元单独维护一个量化缩放系数。
4. q = np.clip(np.round(Wq[:, c] / scale[:, 0]), -qmax, qmax) * scale[:, 0]对当前所有权重列做 4bit 舍入。
5. d = q - Wq[:, c]计算当前列量化前后产生的误差。
6. compensation = np.outer(d / Hinv[c, c], Hinv[c, c + 1:])用反 Hessian 把当前列误差折算成对后面未量化列的补偿。
7. Wq[:, c + 1:] += compensation真正更新后面列，抵消刚才的舍入误差。
8. Wq[:, c] = q写入当前列的量化结果，继续处理下一列。

常见误区

面试题