【模型量化⑤】Weight-Only INT4:AWQ与GPTQ两大算法深度解析

【模型量化⑤】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 能成为大模型推理的主流方案?核心原因有两个:

  1. 显存节省巨大:把 90% 的显存占用(权重)砍到约 1/4,7B 模型从 14GB 降到约 4GB,手机都能跑
  2. 精度相对可控:激活保持 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=max⁡i∈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 的优化目标是最小化层输出的均方误差:

min⁡W^∥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 信息矩阵),目标变成:

min⁡W^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]

开销来源:

  1. 位运算指令:移位、与操作,每个元素都要做
  2. 反量化乘法:乘以 scale 变回 FP16
  3. 访存模式:打包后的数据排布可能不友好,导致 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 量化的两大核心算法:

  1. AWQ:基于「激活重要性感知」的思想,通过缩放权重通道来优化量化精度,实现简单、量化快、零推理开销
  2. GPTQ:基于「Hessian 逆误差补偿」的思想,逐列量化并精确补偿误差,精度更高,但量化更慢、实现更复杂
  3. INT4 Kernel:有「解包后 GEMM」和「原生 INT4 GEMM」两种路径,好的实现一定要融合 unpack 和 GEMM
  4. 工具选择:AutoAWQ / AutoGPTQ 适合入门,vLLM 适合生产,llama.cpp 适合端侧

下一篇,我们会专门来讲 W4A16 分组量化 的工程细节------显存怎么算、推理流程怎么走、MLC-LLM 里怎么实现。这是大模型推理部署中最实用的技能之一。

9.3 思考问题

  1. 为什么 Weight-Only INT4 的激活不量化?如果激活也量化成 INT8(W4A8),会有什么优缺点?

  2. AWQ 中的通道缩放因子 s_j,为什么需要做几何平均归一化?如果不做会怎样? 提示:思考缩放因子整体偏大或偏小对量化的影响。

  3. GPTQ 逐列量化时,为什么要按激活大小排序(desc_act),先量化重要的列? 提示:思考误差补偿的累积效应。

  4. 假设你有一个 70B 的模型,显存只有 24GB,你会选择哪种量化方案?为什么? 提示:计算各方案的显存占用,结合精度要求来分析。

  5. 为什么原生 INT4 Tensor Core(如 Marlin)比「解包到 FP16 再 GEMM」更快?快在哪里? 提示:从计算和访存两个角度分析。


码字不易,如果这篇文章对你有帮助,欢迎点赞收藏关注!下一篇我们讲 W4A16 分组量化的工程实现,不见不散。

相关推荐
水如烟31 分钟前
孤能子视角:通用智能 vs 分工协同智能群系统–––集中结晶 vs 分布式结晶
人工智能
罗西的思考1 小时前
【轻量化复现大模型 / KIMI K3】训练模块梳理 & Muon P2P 优化器
人工智能·深度学习·机器学习
lilihuigz1 小时前
权限配置:WordPress 7.2 Abilities API 权限、输入验证与 JSON 输出指南
人工智能
杨凯凡1 小时前
IT日报|2026-11-20:欧盟 AI 网络攻击、Valkey 9.2、GitHub 企业迁移
人工智能·github
鲁邦通物联网2 小时前
机器人梯控到站状态机设计:楼层匹配、事件时序与任务判断
人工智能·机器人·机器人梯控·agv梯控·非侵入式采集·机器人乘梯·机器人自主乘梯
静水深码2 小时前
文生图提示词的工程师写法:把玄学话术拆成结构化模板
人工智能·后端·代码规范
Seiran2 小时前
Claude Fable 5.1写技术方案,ZEEKEAI提效实录
人工智能
JonaHu2 小时前
GPT Image 2.6 多语言海报改版:保留商品细节,分离文案与图像验收
图像处理·人工智能·aigc
Decay__2 小时前
PostgreSQL 体系架构全解 —— 进程模型、共享内存、MVCC 与 WAL 预写日志深入
运维·数据库·sql·mysql·架构