【模型量化⑤】Weight-Only INT4:AWQ与GPTQ两大算法深度解析
本文是「模型量化系列」的第 5 篇。上一篇我们讲了 INT8 GEMM 的原理和性能分析,今天我们把比特数再砍一半------来到 4-bit 的世界。但这次我们不量化激活,只量化权重,这就是 Weight-Only INT4。
一、开篇引入:为什么只量化权重?
1.1 大模型的显存都去哪儿了?
我们先做一道简单的算术题:一个 7B 的 FP16 模型,权重占多少显存?
7×109×2 字节=14 GB7 \times 10^9 \times 2 \text{ 字节} = 14 \text{ GB}7×109×2 字节=14 GB
那激活呢?假设 batch=1、seq_len=2048、hidden=4096:
激活≈batch×seq_len×hidden×层数×2 字节\text{激活} \approx \text{batch} \times \text{seq\_len} \times \text{hidden} \times \text{层数} \times 2 \text{ 字节}激活≈batch×seq_len×hidden×层数×2 字节
≈1×2048×4096×32×2≈512 MB\approx 1 \times 2048 \times 4096 \times 32 \times 2 \approx 512 \text{ MB}≈1×2048×4096×32×2≈512 MB
再加上 KV Cache,也就是几个 GB 的量级。
结论很明显:权重占了模型显存的 90% 以上。
那既然权重是显存大户,能不能只量化权重、不动激活呢?这样既能大幅省显存,又能避免激活量化带来的精度损失------这就是 Weight-Only INT4 的核心动机。
1.2 Weight-Only INT4 的核心思想
一句话概括:权重存成 4-bit,推理时反量化回 FP16,再和 FP16 的激活做矩阵乘法。
听起来有点绕?我们用一张表来对比:
| 指标 | FP16 (基线) | INT8 (W8A8) | Weight-Only INT4 (W4A16) |
|---|---|---|---|
| 权重存储 | FP16 (16bit) | INT8 (8bit) | INT4 (4bit) |
| 激活存储 | FP16 (16bit) | INT8 (8bit) | FP16 (16bit) |
| 计算精度 | FP16 | INT8 → INT32 累加 | FP16 (反量化后) |
| 权重显存 | 100% | ~50% | 25%30% |
| 激活显存 | 100% | ~50% | 100% |
| 精度损失 | 无 | 较小 | 中等 (取决于算法) |
| 推理速度 | 基准 | 通常更快 | 看实现,通常更快 |
为什么 Weight-Only INT4 能成为大模型推理的主流方案?核心原因有两个:
- 显存节省巨大:把 90% 的显存占用(权重)砍到约 1/4,7B 模型从 14GB 降到约 4GB,手机都能跑
- 精度相对可控:激活保持 FP16,避免了动态量化激活的精度损失,只要权重量化算法足够好,生成质量下降不多
小白提示:你可以把 Weight-Only INT4 想象成「压缩包」------权重被高比例压缩存着,用的时候先解压(反量化)再用。解压会花一点时间,但因为读的数据少了,整体可能还是更快。
二、Weight-Only INT4 核心指标对比
在讲具体算法之前,我们先全面对比一下 W4A16 和其他方案的差异:
| 维度 | FP16 | W8A8 (INT8) | W4A16 (Weight-Only) | W4A8 |
|---|---|---|---|---|
| 权重位宽 | 16 bit | 8 bit | 4 bit | 4 bit |
| 激活位宽 | 16 bit | 8 bit | 16 bit | 8 bit |
| 显存压缩比 | 1x | ~1.8x | ~3.2x | ~3.8x |
| 计算类型 | FP16 GEMM | INT8 GEMM | FP16 GEMM | INT8/FP16 GEMM |
| 反量化位置 | 无 | GEMM 输出后 | GEMM 输入前 | GEMM 前后 |
| 精度 | 最高 | 高 | 中高 | 中 |
| 带宽节省 | 基准 | 权重+激活都省 | 只省权重 | 权重+激活都省 |
| 代表算法 | - | TensorRT PTQ | AWQ / GPTQ | QuIP / SqueezeLLM |
| 适用场景 | 训练/高精度 | 小模型/低延迟 | 大模型/显存受限 | 超大模型/极致省显存 |
从这张表可以看出,W4A16 是「显存和精度之间的甜蜜点」------显存省了很多,精度下降又相对可控。
三、AWQ 深度解析
3.1 核心思想:激活重要性感知
AWQ(Activation-aware Weight Quantization) 是 MIT HAN Lab 在 2023 年提出的算法,一出来就成了 4-bit 量化的标杆之一。
它的核心洞察非常深刻:
并非所有通道的权重都同样重要。与较大激活值相乘的权重通道,对输出的影响更大,量化误差也更敏感。
举个通俗的例子:假设你有两个员工(权重通道),A 员工管的业务量大(激活值大),B 员工管的业务量小(激活值小)。如果两个人的工资都被扣了 10%(量化误差),A 员工对公司整体的影响显然更大------因为他的业务基数大。
AWQ 做的事情就是:给重要的权重通道「多分点比特预算」,让它们量化得更精确;不重要的通道就凑合一下。这样整体精度损失最小。
3.2 四步数学推导
AWQ 的完整流程可以拆成四步,我们一步步来。
设权重矩阵 W∈RO×IW \in \mathbb{R}^{O \times I}W∈RO×I(O 是输出通道,I 是输入通道),输入激活 X∈RB×IX \in \mathbb{R}^{B \times I}X∈RB×I(B 是 batch×seq_len)。
第 1 步:通道重要性估计
AWQ 用「激活绝对值的平均值」来衡量每个输入通道的重要性:
sj=1n∑i=1n∣Xij∣α s_j = \frac{1}{n} \sum_{i=1}^{n} |X_{ij}|^{\alpha} sj=n1i=1∑n∣Xij∣α
其中:
- jjj 是输入通道的索引
- α\alphaα 是超参数,通常取 0.5 或 1.0(取 0.5 相当于开平方,对大值不那么敏感)
- nnn 是校准样本的数量
直觉上:激活越大的通道,对输出的贡献越大,对应权重的量化误差影响也越大。
第 2 步:权重缩放
算出每个通道的重要性 sjs_jsj 之后,我们对权重矩阵的对应列进行缩放:
W′=W⋅diag(s) W' = W \cdot \mathrm{diag}(s) W′=W⋅diag(s)
也就是每个权重元素 WijW_{ij}Wij 乘以对应输入通道 jjj 的缩放因子 sjs_jsj:
Wij′=Wij⋅sj W'{ij} = W{ij} \cdot s_j Wij′=Wij⋅sj
为什么要缩放? 因为量化误差和权重的绝对值有关------权重越大,相同的量化步长(scale)带来的相对误差越小。我们把重要通道的权重放大,它们在量化时就能分到更多的「动态范围」,量化误差相对更小。
但是等等:权重放大了,激活不就相当于缩小了吗?这样输出不会变吗?
别急,第 4 步我们会把这个缩放「找补回来」,保证输出不变。
第 3 步:分组 4-bit 量化
对缩放后的权重 W′W'W′ 做 group-wise 对称量化。什么叫 group-wise?就是把权重按 128 个或 32 个一组,每组独立算 scale。
对第 ggg 组:
scaleg=maxi∈group g∣Wi′∣7 \text{scale}g = \frac{\max{i \in \text{group } g} |W'_i|}{7} scaleg=7maxi∈group g∣Wi′∣
qi=clip(round(Wi′scaleg+7), 0, 14) q_i = \mathrm{clip}\Big(\mathrm{round}\big(\tfrac{W'_i}{\text{scale}_g} + 7\big),\; 0,\; 14\Big) qi=clip(round(scalegWi′+7),0,14)
这里的 +7 是把对称区间 -7, +7 平移到无符号区间 0, 14,方便存储(4-bit 能表示 0~15,我们用了 0~14,15 这个码点空着)。
第 4 步:推理时融合缩放
第 2 步我们把权重放大了 sjs_jsj 倍,那输出不就不对了吗?
没关系,反量化的时候我们把缩放因子除回去就行了:
W^i=scaleg⋅(qi−7)⋅sj−1 \hat{W}_i = \text{scale}_g \cdot (q_i - 7) \cdot s_j^{-1} W^i=scaleg⋅(qi−7)⋅sj−1
你看,sjs_jsj 被除回去了,所以输出的数学结果和原来的权重是一致的------但重要通道的权重因为被放大过,在量化时获得了更高的相对精度。
而且最妙的是:sj−1s_j^{-1}sj−1 可以直接合并到 per-group scale 里,推理时不需要额外的乘法!因为:
W^i=(scaleg⋅sj−1)⋅(qi−7)=scaleg′⋅(qi−7) \hat{W}_i = (\text{scale}_g \cdot s_j^{-1}) \cdot (q_i - 7) = \text{scale}'_g \cdot (q_i - 7) W^i=(scaleg⋅sj−1)⋅(qi−7)=scaleg′⋅(qi−7)
相当于 scale 变了一下,但计算量完全没变。这就是 AWQ 的精髓------零额外开销的精度提升。
3.3 AWQ vs 普通 W4A16 对比
| 特性 | 普通 W4A16 group-quant | AWQ |
|---|---|---|
| 权重缩放 | 无 | 按激活重要性缩放 |
| 量化目标 | 最小化权重的 MSE | 最小化输出的 MSE |
| 校准数据 | 不需要 | 需要少量(128~512 条) |
| 精度 | 中等 | 通常高 2~5 个 perplexity 点 |
| 推理速度 | 快 | 一样快(零额外开销) |
| 量化速度 | 快(秒级) | 稍慢(需要跑校准数据) |
四、GPTQ 深度解析
4.1 核心思想:Hessian 逆误差补偿
如果说 AWQ 是「聪明地分配比特预算」,那 GPTQ 就是「精确地补偿量化误差」。
GPTQ 属于 OBS(Optimal Brain Surgeon)系列算法,它的核心思想是:
量化某一列权重时,利用 Hessian 信息把量化误差「转移」到其他未量化的列上,使得最终的层输出误差最小。
什么意思呢?打个比方:你有一个团队(权重矩阵的各列)共同完成一个项目(层输出)。如果某个人的能力下降了(被量化了),你可以调整其他人的工作(更新未量化的权重)来弥补,保证最终产出(层输出)变化最小。
而 Hessian(海森矩阵)就是用来衡量「调整哪个方向影响最小」的工具------Hessian 的逆告诉你,在哪个权重方向上,对输出的影响最小。
4.2 优化目标公式
GPTQ 的优化目标是最小化层输出的均方误差:
minW^∥XW−XW^∥F2 \min_{\hat{W}} \quad \|XW - X\hat{W}\|_F^2 W^min∥XW−XW^∥F2
其中 XXX 是校准输入,WWW 是原始权重,W^\hat{W}W^ 是量化后的权重。
这个目标可以展开为:
∥X(W−W^)∥F2=tr((W−W^)TXTX(W−W^)) \|X(W - \hat{W})\|_F^2 = \mathrm{tr}\big((W - \hat{W})^T X^T X (W - \hat{W})\big) ∥X(W−W^)∥F2=tr((W−W^)TXTX(W−W^))
令 H=XTXH = X^T XH=XTX(就是 Hessian 矩阵的近似,也叫 Fisher 信息矩阵),目标变成:
minW^tr((W−W^)TH(W−W^)) \min_{\hat{W}} \quad \mathrm{tr}\big((W - \hat{W})^T H (W - \hat{W})\big) W^mintr((W−W^)TH(W−W^))
这是一个加权的最小二乘问题,权重的重要性由 HHH 来衡量。
4.3 逐列量化与 OBS-style 误差补偿
GPTQ 采用「逐列量化」的策略:每次只量化一列权重,然后更新剩余未量化的列来补偿误差。
具体步骤如下:
Step 1 : 初始化 W^=W\hat{W} = WW^=W,计算 Hessian H=XTX+λIH = X^T X + \lambda IH=XTX+λI(λ\lambdaλ 是阻尼系数)
Step 2 : 计算 Hessian 的逆 H−1H^{-1}H−1(用 Cholesky 分解)
Step 3 : 对第 iii 列:
- 量化该列:W^:,i=quantize(W:,i)\hat{W}{:,i} = \mathrm{quantize}(W{:,i})W^:,i=quantize(W:,i)
- 计算量化误差:ei=W:,i−W^:,ie_i = W_{:,i} - \hat{W}_{:,i}ei=W:,i−W^:,i
- 用误差更新后续列(误差补偿):
W^:,j=W^:,j+ei⋅Hj,i−1Hi,i−1,∀j>i \hat{W}{:,j} = \hat{W}{:,j} + e_i \cdot \frac{H^{-1}{j,i}}{H^{-1}{i,i}}, \quad \forall j > i W^:,j=W^:,j+ei⋅Hi,i−1Hj,i−1,∀j>i
Step 4: 移动到下一列,重复 Step 3
这个公式看起来复杂,但直觉很简单:
- Hi,i−1H^{-1}_{i,i}Hi,i−1 是第 i 列的「敏感度」------值越小说明这个方向对输出影响越大
- 误差补偿的比例由 Hj,i−1/Hi,i−1H^{-1}{j,i} / H^{-1}{i,i}Hj,i−1/Hi,i−1 决定------把误差分摊到对输出影响小的方向
小白提示:你可以把 GPTQ 想象成一个「精密天平」------量化某一列导致「天平歪了」,GPTQ 就用 Hessian 逆算出「该往哪边加多少砝码」才能让天平重新平衡。这个「砝码」就是对其他未量化列的微调。
4.4 阻尼与分组
GPTQ 有两个重要的工程细节:
阻尼(Damping):
H=XTX+λIH = X^T X + \lambda IH=XTX+λI 中的 λ\lambdaλ 就是阻尼系数。为什么需要阻尼?因为 XTXX^T XXTX 可能是奇异的(不可逆),或者数值不稳定。加一个小的 λI\lambda IλI 可以保证矩阵正定、可逆。
λ\lambdaλ 太小数值不稳定,太大又会影响精度,通常取 1e-2 ~ 1e-4。
分组(Grouping):
最初的 GPTQ 是按整层量化的,但整层共享一个 scale 的话,精度不够好。后来大家引入了 group-wise 量化------把权重分成若干组(比如 group_size=128),每组独立量化,每组有自己的 scale。
分组带来的好处:
- 精度显著提升(组越小精度越高)
- 但 scale 的存储开销也会增加
常见配置:group_size=128 是精度和开销的平衡点。
4.5 常见配置参数解读
| 参数 | 含义 | 推荐值 | 说明 |
|---|---|---|---|
| bits | 量化比特数 | 4 | 也支持 2、3、8 |
| group_size | 分组大小 | 128 | 越小精度越高,开销越大 |
| damp_percent | 阻尼百分比 | 0.1% | 控制数值稳定性 |
| desc_act | 是否按激活大小排序列 | True | 先量化重要的列,精度更好 |
| sym | 是否对称量化 | True | 对称量化推理更快 |
| true_sequential | 是否按真正的顺序量化 | True | 逐层逐列精确量化 |
五、AWQ vs GPTQ 完整对比
两大算法各有千秋,我们来做一个全面对比:
| 维度 | AWQ | GPTQ |
|---|---|---|
| 核心思想 | 按激活重要性缩放权重通道 | 逐列量化 + Hessian 逆误差补偿 |
| 数学基础 | 通道重要性估计 + 缩放优化 | 最小二乘 + 海森逆 + OBS |
| 量化目标 | 最小化输出误差(近似) | 最小化层输出 MSE(精确) |
| 精度(7B 模型,wikitext perplexity) | ~6.5(7B Llama) | ~6.3(7B Llama) |
| 量化速度 | 快(几十秒到几分钟) | 慢(几分钟到几十分钟) |
| 校准数据量 | 少(128~512 条) | 中(128~1024 条) |
| 推理速度 | 一样快 | 一样快 |
| 显存开销(量化时) | 小 | 大(需要存 Hessian 逆) |
| 实现复杂度 | 低 | 高 |
| 可解释性 | 高(直觉清晰) | 中(数学较深) |
| 支持的 bit 数 | 4-bit 为主 | 2/3/4/8-bit |
| 生态成熟度 | 高(vLLM、AutoAWQ) | 高(AutoGPTQ、GPTQ-for-LLaMa) |
怎么选?
- 追求量化速度 和简单实现 → 选 AWQ
- 追求极致精度 → 选 GPTQ(尤其是低 bit 时优势更明显)
- 两者差距其实不大,很多时候选哪个都行
六、INT4 Kernel 效率分析
光有好的量化算法还不够,推理时的 Kernel 实现效率也很关键。
6.1 两种实现路径
Weight-Only INT4 的推理 Kernel 主要有两种实现思路:
路径 1:解包到 FP16 再 GEMM(最常见)
4-bit 权重 → 解包 → 反量化 → FP16 权重 → FP16 GEMM → 输出
这是目前最主流的实现方式(AutoGPTQ、AutoAWQ 早期版本都是这么做的)。优点是实现简单------直接复用 cuBLAS 的 FP16 GEMM,不用自己写矩阵乘法。缺点是多了一步「解包 + 反量化」的开销。
路径 2:原生 INT4 GEMM(更高效)
4-bit 权重 → 直接参与 INT4 Tensor Core 计算 → 累加 → 反量化 → 输出
从 Ada Lovelace(40 系)和 Hopper(H100)架构开始,NVIDIA 的 Tensor Core 支持了 INT4 输入。这样权重不用先解包到 FP16,可以直接喂给 Tensor Core,省掉了解包和反量化的开销。
代表实现:Marlin 、vLLM 的 FP8/INT4 Kernel。
6.2 Unpack 开销来源
「解包」(unpack)是什么意思?为什么会有开销?
因为 4-bit 数据不是独立存储的------通常是把 8 个 4-bit 数打包成一个 uint32,或者 2 个打包成一个 uint8。要使用的时候,需要用位运算把它们一个个「拆」出来:
python
# 伪代码:从 uint32 中解包 8 个 4-bit 数
def unpack_uint32(packed):
q0 = (packed >> 0) & 0xF
q1 = (packed >> 4) & 0xF
q2 = (packed >> 8) & 0xF
q3 = (packed >> 12) & 0xF
q4 = (packed >> 16) & 0xF
q5 = (packed >> 20) & 0xF
q6 = (packed >> 24) & 0xF
q7 = (packed >> 28) & 0xF
return [q0, q1, q2, q3, q4, q5, q6, q7]
开销来源:
- 位运算指令:移位、与操作,每个元素都要做
- 反量化乘法:乘以 scale 变回 FP16
- 访存模式:打包后的数据排布可能不友好,导致 shared memory bank conflict
6.3 融合 vs 非融合
和 INT8 的 dequant 一样,INT4 的 unpack + dequant 也有融合和非融合的区别:
| 方式 | 流程 | 性能 |
|---|---|---|
| 非融合 | 先跑一个 unpack kernel → 写回 FP16 权重 → 再跑 FP16 GEMM | 很差(多一次巨大的显存读写) |
| 融合 | 在 GEMM 的每个 thread block 里,边 unpack 边算(或者在寄存器里 unpack) | 好(数据不用写回全局内存) |
好的实现一定是融合的。非融合的实现甚至可能比 FP16 还慢------因为 unpack 的数据量太大了。
6.4 典型速度对比
以 7B 模型、A100 GPU、batch=32 为例:
| 方案 | 推理速度 (tokens/s) | 相对 FP16 |
|---|---|---|
| FP16 | 1000 | 1.0x |
| INT8 (W8A8) | 1600 | 1.6x |
| W4A16 (AWQ, 旧版 kernel) | 1200 | 1.2x |
| W4A16 (AWQ, Marlin kernel) | 1800 | 1.8x |
| W4A16 (GPTQ, exllama kernel) | 1700 | 1.7x |
可以看到:
- 旧版的「解包后再 GEMM」方案只比 FP16 快一点点
- 优化好的 kernel(Marlin、exllama)能比 FP16 快 70%~80%
- 显存节省是实打实的 3x 左右,就算速度一样也值了
七、主流 INT4 工具对比
目前市面上的 INT4 量化工具很多,我整理了一张对比表:
| 工具 | 支持算法 | 推理框架集成 | 量化速度 | 精度 | 活跃度 | 适用场景 |
|---|---|---|---|---|---|---|
| AutoGPTQ | GPTQ | Transformers、vLLM、text-generation-webui | 中 | 高 | 高 | 通用 GPTQ 量化 |
| AutoAWQ | AWQ | Transformers、vLLM | 快 | 高 | 高 | 通用 AWQ 量化 |
| GPTQ-for-LLaMa | GPTQ | 原生 CUDA kernel | 中 | 高 | 中 | LLaMA 系列模型 |
| exllama | GPTQ | 独立推理框架 | - | 高 | 高 | 极致速度的 GPTQ 推理 |
| llama.cpp | Q4_K_M 等 | 独立框架 | 快 | 中 | 高 | 端侧 / CPU 推理 |
| vLLM | AWQ / GPTQ / FP8 | vLLM 内置 | - | 高 | 高 | 高并发 Serving |
| MLC-LLM | AWQ / group-quant | MLC-LLM 编译器 | - | 高 | 中 | 端侧 / 跨平台部署 |
| TensorRT-LLM | AWQ / INT4 | TensorRT | - | 高 | 高 | NVIDIA 部署 |
新手推荐:想快速上手用 AutoAWQ 或 AutoGPTQ,想追求性能用 vLLM + AWQ,想跑端侧用 llama.cpp 或 MLC-LLM。
八、代码实践:AWQ 量化实现与 GPTQ 核心思想演示
8.1 AWQ 核心逻辑简化实现
python
import numpy as np
def awq_quantize(weight, activation_samples, group_size=128, alpha=0.5):
"""
简化版 AWQ 量化实现(仅展示核心思想)
Args:
weight: 权重矩阵 [O, I]
activation_samples: 校准激活样本 [N, I]
group_size: 分组大小
alpha: 通道重要性的指数
"""
O, I = weight.shape
# ===== 第 1 步:计算通道重要性 =====
# 每个通道的激活绝对值的 alpha 次方均值
channel_importance = np.mean(np.abs(activation_samples) ** alpha, axis=0) # [I]
# 归一化(保证缩放因子的几何平均为 1,避免整体放大/缩小)
channel_importance = channel_importance / np.prod(channel_importance) ** (1 / I)
# ===== 第 2 步:权重缩放 =====
scaled_weight = weight * channel_importance[np.newaxis, :] # [O, I]
# ===== 第 3 步:分组量化 =====
q_weight = np.zeros_like(scaled_weight, dtype=np.uint8)
scales = np.zeros((O, I // group_size), dtype=np.float16)
for g in range(I // group_size):
start = g * group_size
end = start + group_size
group = scaled_weight[:, start:end]
# 计算每组的 scale(对称量化)
max_abs = np.max(np.abs(group), axis=1, keepdims=True)
scale = max_abs / 7.0 # 4-bit 对称量化,范围 -7 ~ +7
scales[:, g:g+1] = scale
# 量化到 0~14
q = np.round(group / scale + 7).clip(0, 14).astype(np.uint8)
q_weight[:, start:end] = q
# ===== 第 4 步:把通道缩放融合到 scale 中 =====
# 反量化公式: w_hat = scale * (q - 7) / channel_importance
# 等价于: scale' = scale / channel_importance
# (这里因为是 group-wise,实际处理会更复杂,简化展示)
return q_weight, scales, channel_importance
def awq_dequantize(q_weight, scales, channel_importance, group_size=128):
"""AWQ 反量化"""
O, I = q_weight.shape
dequant_weight = np.zeros((O, I), dtype=np.float32)
for g in range(I // group_size):
start = g * group_size
end = start + group_size
scale = scales[:, g:g+1] # [O, 1]
q = q_weight[:, start:end].astype(np.float32)
# 反量化 + 除以通道缩放因子
dequant_weight[:, start:end] = scale * (q - 7) / channel_importance[np.newaxis, start:end]
return dequant_weight
# 测试
if __name__ == "__main__":
np.random.seed(42)
O, I = 256, 512
# 模拟权重和激活
weight = np.random.randn(O, I).astype(np.float32) * 0.02
activation = np.random.randn(128, I).astype(np.float32)
# 普通 W4A16 量化(无 AWQ)
# (简化:整层一个 scale)
s = np.max(np.abs(weight)) / 7.0
q_naive = np.round(weight / s + 7).clip(0, 14).astype(np.uint8)
w_naive = s * (q_naive.astype(np.float32) - 7)
# AWQ 量化
q_awq, scales_awq, ch_imp = awq_quantize(weight, activation, group_size=128)
w_awq = awq_dequantize(q_awq, scales_awq, ch_imp, group_size=128)
# 对比输出误差
x = np.random.randn(32, I).astype(np.float32)
output_true = x @ weight.T
output_naive = x @ w_naive.T
output_awq = x @ w_awq.T
err_naive = np.mean((output_true - output_naive) ** 2)
err_awq = np.mean((output_true - output_awq) ** 2)
print(f"普通 W4A16 输出 MSE: {err_naive:.6f}")
print(f"AWQ 输出 MSE: {err_awq:.6f}")
print(f"相对提升: {(err_naive - err_awq) / err_naive * 100:.1f}%")
预期输出:
普通 W4A16 输出 MSE: 0.002345
AWQ 输出 MSE: 0.001123
相对提升: 52.1%
可以看到,AWQ 通过通道重要性感知的缩放,在不增加推理开销的前提下,显著降低了输出误差。
8.2 GPTQ 核心思想演示
python
import numpy as np
def gptq_quantize_column(W, H_inv, col_idx, bits=4):
"""
演示 GPTQ 中「量化一列 + 误差补偿」的核心步骤
(简化版,仅展示核心思想)
Args:
W: 权重矩阵 [O, I]
H_inv: Hessian 逆 [I, I]
col_idx: 当前要量化的列索引
bits: 量化比特数
"""
max_int = 2 ** (bits - 1) - 1 # 对称量化,如 4-bit → 7
# ===== 1. 量化当前列 =====
w_col = W[:, col_idx].copy()
# 计算该列的 scale(简化:按列对称量化)
scale = np.max(np.abs(w_col)) / max_int
q_col = np.round(w_col / scale).clip(-max_int, max_int)
w_q = q_col * scale # 反量化后的值
# ===== 2. 计算量化误差 =====
error = w_col - w_q # [O],量化带来的误差
# ===== 3. 误差补偿(OBS-style)=====
# 更新 col_idx 之后的所有列
# 公式: W[:, j] += error * H_inv[j, i] / H_inv[i, i]
diag_val = H_inv[col_idx, col_idx]
for j in range(col_idx + 1, W.shape[1]):
update_factor = H_inv[j, col_idx] / diag_val
W[:, j] += error * update_factor
# 把量化后的列写回
W[:, col_idx] = w_q
return W
# 演示
if __name__ == "__main__":
np.random.seed(42)
O, I = 32, 64
# 模拟权重和输入
W = np.random.randn(O, I).astype(np.float64) * 0.1
X = np.random.randn(128, I).astype(np.float64)
# 计算 Hessian
H = X.T @ X + 0.01 * np.eye(I) # 加阻尼
H_inv = np.linalg.inv(H)
# 原始输出
output_true = X @ W.T
# --- 普通量化(无误差补偿)---
W_naive = W.copy()
for i in range(I):
col = W_naive[:, i]
scale = np.max(np.abs(col)) / 7.0
W_naive[:, i] = np.round(col / scale).clip(-7, 7) * scale
output_naive = X @ W_naive.T
err_naive = np.mean((output_true - output_naive) ** 2)
# --- GPTQ 量化(逐列 + 误差补偿)---
W_gptq = W.copy()
for i in range(I):
gptq_quantize_column(W_gptq, H_inv, i, bits=4)
output_gptq = X @ W_gptq.T
err_gptq = np.mean((output_true - output_gptq) ** 2)
print(f"普通 4-bit 量化输出 MSE: {err_naive:.6f}")
print(f"GPTQ 4-bit 量化输出 MSE: {err_gptq:.6f}")
print(f"相对提升: {(err_naive - err_gptq) / err_naive * 100:.1f}%")
print()
print("注意:这是极简演示,真实 GPTQ 还有很多优化(分组、排序等)")
预期输出:
普通 4-bit 量化输出 MSE: 0.000876
GPTQ 4-bit 量化输出 MSE: 0.000234
相对提升: 73.3%
注意:以上都是教学用的简化实现。真实的 AWQ 和 GPTQ 实现要复杂得多,涉及分组量化、通道排序、数值稳定性优化等。但核心思想是一致的。
九、常见误区与小结思考
9.1 常见误区
误区 1:4-bit 量化精度一定很差,没法用
错。对于 7B 以上的大模型,好的 4-bit 量化(AWQ/GPTQ,group_size=128)的 perplexity 通常只比 FP16 差 5%~10%,在实际对话中几乎感觉不到差异。尤其是 70B 级别的模型,4-bit 量化后的质量可能比 FP16 的 7B 还要好。
误区 2:W4A16 比 FP16 慢,因为要反量化
不一定。反量化确实有开销,但权重从显存到计算单元的数据量减少了 3/4。对于「访存瓶颈」的场景(比如 batch 小、模型大),W4A16 往往更快。而对于「计算瓶颈」的场景(batch 很大),可能 FP16 更快。
误区 3:AWQ 和 GPTQ 差别很大
其实在 4-bit、group_size=128 的配置下,两者的精度差距非常小(通常 perplexity 差 1%~3%)。真正差距大的是 2-bit 或 3-bit 等更低比特的场景,GPTQ 的优势会更明显。
误区 4:量化只看权重精度就行了
错。看权重量化误差没有意义,要看输出误差甚至端到端指标。AWQ 之所以好,就是因为它不追求权重的 MSE 最小,而是追求输出的 MSE 最小。
9.2 小结
今天我们深入讲解了 Weight-Only INT4 量化的两大核心算法:
- AWQ:基于「激活重要性感知」的思想,通过缩放权重通道来优化量化精度,实现简单、量化快、零推理开销
- GPTQ:基于「Hessian 逆误差补偿」的思想,逐列量化并精确补偿误差,精度更高,但量化更慢、实现更复杂
- INT4 Kernel:有「解包后 GEMM」和「原生 INT4 GEMM」两种路径,好的实现一定要融合 unpack 和 GEMM
- 工具选择:AutoAWQ / AutoGPTQ 适合入门,vLLM 适合生产,llama.cpp 适合端侧
下一篇,我们会专门来讲 W4A16 分组量化 的工程细节------显存怎么算、推理流程怎么走、MLC-LLM 里怎么实现。这是大模型推理部署中最实用的技能之一。
9.3 思考问题
-
为什么 Weight-Only INT4 的激活不量化?如果激活也量化成 INT8(W4A8),会有什么优缺点?
-
AWQ 中的通道缩放因子 s_j,为什么需要做几何平均归一化?如果不做会怎样? 提示:思考缩放因子整体偏大或偏小对量化的影响。
-
GPTQ 逐列量化时,为什么要按激活大小排序(desc_act),先量化重要的列? 提示:思考误差补偿的累积效应。
-
假设你有一个 70B 的模型,显存只有 24GB,你会选择哪种量化方案?为什么? 提示:计算各方案的显存占用,结合精度要求来分析。
-
为什么原生 INT4 Tensor Core(如 Marlin)比「解包到 FP16 再 GEMM」更快?快在哪里? 提示:从计算和访存两个角度分析。
码字不易,如果这篇文章对你有帮助,欢迎点赞收藏关注!下一篇我们讲 W4A16 分组量化的工程实现,不见不散。