【模型量化⑦】W4A8与GPTQ-Int4:极限压缩与MLC-LLM部署实战
本文是「模型量化」系列的第 7 篇,带你从原理到实战,彻底搞懂 W4A8 与 GPTQ-Int4 量化方案,并通过 MLC-LLM 完成端到端的模型导出与推理部署。
一、开篇引入:W4A8------比W4A16更激进的低比特方案
在前面的章节中,我们已经学习了 W4A16(4-bit 权重 + 16-bit 激活)量化方案,它能把模型显存压缩到原来的约 1/3,是目前大模型推理的主流选择。
但是,你有没有想过一个问题:权重压到 4-bit 了,激活还是 FP16,能不能再激进一点?
答案是肯定的,这就是我们今天的主角------W4A8。
1.1 什么是 W4A8
用一句话概括:W4A8 = 4-bit 权重 + 8-bit 激活。
| 组件 | 精度 | 占比 | 作用 |
|---|---|---|---|
| 权重(Weights) | 4-bit | 模型 90%+ 显存 | 进一步压缩到 FP16 的 1/4 |
| 激活(Activations) | 8-bit | 推理中间值 | 降低带宽需求和中间显存 |
| 计算时 | 混合精度 GEMM | - | INT8 Tensor Core 上完成矩阵乘 |
1.2 为什么需要 W4A8
你可能会问:W4A16 已经很香了,为什么还要折腾 W4A8?主要有三个原因:
1. 显存极限压缩
以一个 70B 模型为例:
- FP16 权重:约 140GB
- W4A16 权重:约 44GB(压缩 3.2 倍)
- W4A8 权重 + 激活:比 W4A16 再省约 20% 的整体显存
在单卡或双卡部署大模型时,每省 1GB 显存都可能意味着能否"塞得下"。
2. 算力换显存,提升吞吐
现代 NVIDIA GPU 的 INT8 Tensor Core 吞吐通常是 FP16 的 2 倍。如果激活也量化到 INT8,矩阵乘法可以完全在 INT8 计算单元上运行,理论吞吐更高。
3. 服务化降本
在相同硬件上,W4A8 可以部署更大的模型,或者承载更高的并发请求。对于云服务厂商来说,这直接对应着成本的下降。
1.3 W4A8 与 GPTQ-Int4 的关系
很多同学会混淆这两个概念,这里先澄清一下:
- GPTQ-Int4 :指用 GPTQ 算法把权重量化到 4-bit ,默认激活保持 FP16,所以严格来说是 W4A16。
- W4A8 :权重 4-bit + 激活 8-bit 的混合方案。权重可以用 GPTQ 量化,也可以用 AWQ 或其他方法。
简单说:GPTQ-Int4 是 W4A16 的一种权重实现方式;而 W4A8 是在 W4A16 基础上,把激活也进一步量化到 8-bit。
二、W4A8 数学定义:从原理到公式
理解 W4A8 的关键是搞清楚两部分:权重量化 和激活量化,以及它们如何在 GEMM(矩阵乘法)中配合工作。
2.1 权重量化:GPTQ group-wise 对称量化
GPTQ 是目前最流行的 4-bit 权重量化算法之一。它的核心思想不是简单地逐层量化,而是用类似"最优脑外科医生(OBS)"的思路,在层内优化权重误差,让量化带来的精度损失尽可能小。
不过对于初学者来说,我们先掌握分组对称量化的基本公式就够了。
设权重矩阵 W∈RO×IW \in \mathbb{R}^{O \times I}W∈RO×I,其中 OOO 是输出维度,III 是输入维度。我们沿输入维度按 group_size=128 分组,对每组 ggg:
第一步:求每组的最大绝对值
max_absg=maxi∈group g∣Wi∣ \text{max\_abs}g = \max{i \in \text{group } g} |W_i| max_absg=i∈group gmax∣Wi∣
第二步:计算缩放因子 scale
scaleg=max_absg24−1−1=max_absg7 \text{scale}_g = \frac{\text{max\_abs}_g}{2^{4-1}-1} = \frac{\text{max\_abs}_g}{7} scaleg=24−1−1max_absg=7max_absg
这里除以 7 是因为 4-bit 对称量化的范围是 -7, 7(共 15 个非零值 + 0,实际用 14 个等级)。
第三步:量化
qi=clip(round(Wiscaleg), −7, 7) q_i = \mathrm{clip}\Big(\mathrm{round}\big(\tfrac{W_i}{\text{scale}_g}\big),\; -7,\; 7\Big) qi=clip(round(scalegWi),−7,7)
小白提示 :
group_size=128是什么意思?就是每 128 个权重共享一个 scale。group_size 越小,精度越高,但 scale 占用的显存也越多。128 是一个常用的平衡点。
2.2 激活量化:per-token / per-tensor
输入激活 x∈RB×Ix \in \mathbb{R}^{B \times I}x∈RB×I,其中 BBB 是 batch size,III 是特征维度。
激活量化通常采用 per-token 或 per-tensor 粒度:
sx=max(∣x∣)127,xq=round(xsx) s_x = \frac{\max(|x|)}{127}, \quad x_q = \mathrm{round}\Big(\frac{x}{s_x}\Big) sx=127max(∣x∣),xq=round(sxx)
xq∈−128,127x_q \in -128, 127xq∈−128,127,用 INT8 存储。
- per-tensor:整个张量共享一个 scale,计算简单,但精度较低。
- per-token:每个 token 独立计算 scale,精度更高,是 LLM 推理的常用选择。
2.3 W4A8 GEMM 公式
当权重和激活都量化后,矩阵乘法怎么算?
C=sx⋅sW⋅(XINT8×WINT4/INT8) C = s_x \cdot s_W \cdot (X_{\text{INT8}} \times W_{\text{INT4}/\text{INT8}}) C=sx⋅sW⋅(XINT8×WINT4/INT8)
翻译成人话:
- 先把 INT8 激活和 INT4 权重做整数矩阵乘法,得到 INT32 累加结果。
- 最后乘以激活的 scale 和权重的 scale,反量化回 FP16/FP32。
在实际实现中,INT4 权重通常会先解包成 INT8,或者使用专门的 INT4 kernel(如 Marlin、Tensor Core INT4 路径)直接与 INT8 激活相乘。
三、Qwen3.5-35B-A3B-GPTQ-Int4 配置解读
光说理论不够,我们拿一个真实的量化模型来"解剖"------Qwen/Qwen3.5-35B-A3B-GPTQ-Int4。
这是通义千问的一个 MoE(混合专家)模型,总参数量 35B,激活参数量只有 3B,并且用 GPTQ 量化到了 4-bit。
3.1 MoE 架构要点
先看模型结构配置的关键字段:
json
{
"architectures": ["Qwen3_5MoeForConditionalGeneration"],
"model_type": "qwen3_5_moe",
"text_config": {
"hidden_size": 2048,
"num_hidden_layers": 40,
"num_attention_heads": 16,
"num_key_value_heads": 2,
"num_experts": 256,
"num_experts_per_tok": 8,
"moe_intermediate_size": 512,
"shared_expert_intermediate_size": 512,
"vocab_size": 248320,
"max_position_embeddings": 262144
}
}
几个关键信息:
| 字段 | 数值 | 含义 |
|---|---|---|
num_experts |
256 | 总共有 256 个专家 |
num_experts_per_tok |
8 | 每个 token 只激活 8 个专家(MoE 的核心) |
num_attention_heads |
16 | 注意力头数 |
num_key_value_heads |
2 | GQA(分组查询注意力),KV Cache 更省 |
max_position_embeddings |
262144 | 支持 256K 超长上下文 |
小白科普:MoE(混合专家)模型的思路是"人多力量大,但不用所有人都上"。总共有 256 个专家网络,但每个 token 只选最相关的 8 个来计算,这样总参数量很大,但实际计算量很小。
3.2 GPTQ 量化配置要点
再看量化配置:
json
{
"quantization_config": {
"quant_method": "gptq",
"bits": 4,
"group_size": 128,
"sym": true,
"desc_act": false,
"damp_percent": 0.01,
"true_sequential": true,
"dynamic": {
"lm_head": {},
"model.language_model.embed_tokens": {},
"-:.*attn.*": {},
"-:.*shared_expert.*": {},
"-:.*mtp.*": {},
"-:.*visual.*": {}
}
}
}
每个字段是什么意思呢?我帮你整理成表格:
| 字段 | 值 | 含义 | 小白解读 |
|---|---|---|---|
bits |
4 | 每个权重用 4-bit 存储 | 压缩到原来的 1/4 |
group_size |
128 | 每 128 个权重共享一个 scale | 精度 vs 显存的平衡点 |
sym |
true | 对称量化 | 零点为 0,不用存 zero_point,省空间 |
desc_act |
false | 不按激活大小重排 | 推理更快,但精度略低 |
damp_percent |
0.01 | GPTQ 阻尼系数 | 防止 Hessian 矩阵求逆时数值不稳定 |
true_sequential |
true | 严格按顺序处理层 | 与 GPTQ 论文一致,精度更有保障 |
dynamic |
- | 动态排除某些模块 | 注意力层、embedding、视觉模块等保持原精度 |
划重点 :
dynamic字段告诉我们,不是所有层都需要量化。像 embedding、lm_head、注意力层这些对精度敏感的模块,通常保持 FP16 效果更好。
四、MLC-LLM 中的量化模式
MLC-LLM 是一个基于 TVM/Relax 的大模型推理编译框架,支持多种量化模式。如果你想在端侧或者追求极致编译优化,MLC-LLM 是一个非常好的选择。
4.1 常用量化模式对比
| MLC 模式 | 权重精度 | 激活精度 | 说明 |
|---|---|---|---|
q0f16 |
FP16 | FP16 | 无量化,基准 |
q0f32 |
FP32 | FP32 | 无量化,更高精度但更慢 |
q4f16_1 |
INT4 group-wise | FP16 | W4A16,MLC 默认分组量化 |
q4f16_2 |
INT4 group-wise | FP16 | 不同的权重布局,性能可能更优 |
q4f32_1 |
INT4 | FP32 | 精度更高,但速度慢 |
q8f16_1 |
INT8 | FP16 | W8A16,精度更高 |
注意 :MLC-LLM 目前没有专门的
q4f16_gptq模式。对于 GPTQ/AWQ 预量化模型,通常需要用q4f16_1或q4f16_2重新导出,或者先转换权重格式。
对于我们的 Qwen3.5-35B-A3B-GPTQ-Int4 模型,因为本质上是 W4A16 权重量化,首选 q4f16_1 或 q4f16_2 进行导出。
五、MLC-LLM 导出 TVM 模型完整流程
MLC-LLM 的导出流程分为三步,非常清晰:gen_config → convert → compile。
5.1 环境准备
首先安装 MLC-LLM(以 CUDA 12.1 为例):
bash
pip install --pre -U -f https://mlc.ai/wheels \
mlc-llm-nightly-cu121 \
mlc-ai-nightly-cu121
# 验证安装
python -c "import mlc_llm; print(mlc_llm.__version__)"
5.2 三步导出流程
假设你已经把模型下载到本地,路径为 $HF_MODEL,输出目录为 $MLC_OUT。
第一步:生成配置(gen_config)
bash
mlc_llm gen_config $HF_MODEL \
--quantization q4f16_1 \
--conv-template qwen3_5 \
--output $MLC_OUT
这一步会读取 HuggingFace 模型的 config.json,生成 MLC 格式的 mlc_chat_config.json,包含量化参数、tokenizer 配置、对话模板等信息。
第二步:转换权重(convert)
bash
mlc_llm convert $HF_MODEL \
--quantization q4f16_1 \
--output $MLC_OUT
这一步把 HuggingFace 格式的权重转换为 MLC/TVM 支持的参数格式,并按照指定的量化方案进行量化或重新排列。
第三步:编译模型(compile)
bash
mlc_llm compile $MLC_OUT \
--device cuda \
--output $MLC_OUT/lib.so
这一步用 TVM 把模型编译成目标硬件的优化库(CUDA 上是 .so 文件)。编译完成后,模型就可以高效推理了。
为什么要分三步?
gen_config:确定模型结构和量化配置(元数据层面)convert:处理权重数据(数据层面)compile:生成优化的计算图和 kernel(计算层面)三步分离的好处是灵活------比如你想换个量化模式,可能只需要重新 convert 和 compile,而不用从头来。
六、MLC-LLM 推理代码实战
导出完成后,就可以用 MLC-LLM 进行推理了。MLC-LLM 提供了两种常用接口:**ChatModule(同步)**和 MLCEngine(流式)。
6.1 ChatModule:同步接口
最简单的推理方式,适合快速验证:
python
from mlc_llm import ChatModule
model_path = "./qwen3.5-35b-a3b-gptq-int4-mlc"
# 加载模型
cm = ChatModule(
model=model_path,
device="cuda",
)
# 生成回复
prompt = "请用一句话介绍 Qwen3.5 MoE 模型。"
response = cm.generate(prompt)
print(response)
6.2 MLCEngine:流式接口
生产环境中,流式输出体验更好。MLCEngine 支持异步流式推理:
python
from mlc_llm import MLCEngine
# 创建引擎
engine = MLCEngine(
model="./qwen3.5-35b-a3b-gptq-int4-mlc",
device="cuda",
)
# 流式生成
print("Assistant: ", end="", flush=True)
for text in engine.generate("你好,请介绍一下自己。"):
print(text, end="", flush=True)
print()
七、W4A8 vs W4A16 vs GPTQ-Int4 对比表
学了这么多,来一张总结表帮你理清思路:
| 方案 | 权重精度 | 激活精度 | 压缩比(相对FP16) | 生成质量 | 适用场景 |
|---|---|---|---|---|---|
| FP16 | 16-bit | 16-bit | 1x | 最高 | 训练、高质量推理 |
| W8A16 | 8-bit | 16-bit | ~2x | 较高 | 权重敏感任务 |
| GPTQ-Int4 | 4-bit | 16-bit | ~3.2x | 较高 | 大模型推理主流 |
| W4A8 | 4-bit | 8-bit | ~4x | 中等 | 极限压缩、高吞吐 |
| W2A16 | 2-bit | 16-bit | ~6x | 较低 | 实验性方案 |
记住这个关系:GPTQ-Int4 本质上是 W4A16 的一种权重实现。W4A8 是在 W4A16 基础上,把激活也量化到 8-bit,进一步压缩显存,但精度损失也更大。
八、代码实践:W4A8 量化实现 + 推理流程演示
理论说了这么多,我们动手写代码,亲手实现一个简化版的 W4A8 量化和推理流程。
8.1 W4A8 量化实现
下面这段代码实现了 GPTQ 风格的 4-bit 分组对称量化,并在此基础上加入 8-bit 激活量化:
python
import torch
import torch.nn as nn
def pack_int4_to_uint8(int4_weights):
"""将两个 int4 打包成一个 uint8,节省存储空间"""
shape = int4_weights.shape
last_dim = shape[-1]
assert last_dim % 2 == 0, "最后一维必须是 2 的倍数"
packed_shape = list(shape[:-1]) + [last_dim // 2]
w = int4_weights.reshape(packed_shape + [2])
shifts = torch.tensor([0, 4], device=w.device, dtype=torch.uint8)
packed = (w.to(torch.uint8) << shifts).sum(dim=-1)
return packed
def unpack_uint8_to_int4(packed_weights):
"""将 uint8 解包成两个 int4"""
q_low = packed_weights & 0xF
q_high = (packed_weights >> 4) & 0xF
q = torch.stack([q_low, q_high], dim=-1)
return q.reshape(*packed_weights.shape[:-1], -1)
class W4A8Linear:
"""W4A8 线性层:4-bit 权重 + 8-bit 激活"""
def __init__(self, in_features, out_features, group_size=128):
self.in_features = in_features
self.out_features = out_features
self.group_size = group_size
self.num_groups = (in_features + group_size - 1) // group_size
def quantize_weight(self, weight):
"""对权重进行 4-bit 分组对称量化"""
out_c, in_c = weight.shape
# 补齐到 group_size 的整数倍
pad_len = (self.group_size - in_c % self.group_size) % self.group_size
if pad_len > 0:
weight = torch.nn.functional.pad(weight, (0, pad_len), value=0)
# 按组 reshape
w_groups = weight.reshape(out_c, self.num_groups, self.group_size)
max_abs = w_groups.abs().max(dim=-1, keepdim=True).values
max_abs = torch.where(max_abs == 0, torch.ones_like(max_abs), max_abs)
# 计算 scale 并量化
self.scales = (max_abs / 7.0).to(torch.float16) # 4-bit 对称量化范围 [-7,7]
q = torch.round(w_groups / self.scales + 7).clamp(0, 14).to(torch.uint8)
q = q.reshape(out_c, self.num_groups * self.group_size)
self.qweight = pack_int4_to_uint8(q) # 打包成 uint8
def quantize_activation(self, x):
"""对激活进行 8-bit 对称量化(per-token)"""
max_abs = x.abs().max(dim=-1, keepdim=True).values
max_abs = torch.where(max_abs == 0, torch.ones_like(max_abs), max_abs)
scale = max_abs / 127.0
x_q = torch.round(x / scale).clamp(-128, 127).to(torch.int8)
return x_q, scale
def forward(self, x):
"""前向传播:简化版本(真实 kernel 会直接在 INT8/INT4 上做 GEMM)"""
# 1. 量化激活
x_q, x_scale = self.quantize_activation(x)
x_deq = x_q.to(torch.float16) * x_scale
# 2. 反量化权重
q = unpack_uint8_to_int4(self.qweight)
q = q[:, :self.in_features]
q = q.reshape(self.out_features, self.num_groups, self.group_size)
w_deq = self.scales * (q.to(torch.float32) - 7.0)
w_deq = w_deq.reshape(self.out_features, -1)[:, :self.in_features]
w_deq = w_deq.to(torch.float16)
# 3. 矩阵乘法(实际生产中应使用 INT8 GEMM kernel)
return torch.matmul(x_deq, w_deq.t())
# 测试
def test_w4a8():
torch.manual_seed(42)
in_f, out_f = 256, 128
group_size = 128
x = torch.randn(2, 8, in_f, dtype=torch.float16)
# FP16 基准
fc = nn.Linear(in_f, out_f, dtype=torch.float16)
# W4A8 量化
w4a8_fc = W4A8Linear(in_f, out_f, group_size=group_size)
w4a8_fc.quantize_weight(fc.weight.data)
# 对比输出
y_fp16 = fc(x)
y_w4a8 = w4a8_fc.forward(x)
mse = torch.mean((y_fp16 - y_w4a8) ** 2).item()
print(f"FP16 vs W4A8 MSE: {mse:.6f}")
fp16_bytes = fc.weight.numel() * 2
qweight_bytes = w4a8_fc.qweight.numel()
scales_bytes = w4a8_fc.scales.numel() * 2
total_bytes = qweight_bytes + scales_bytes
print(f"权重压缩比: {fp16_bytes / total_bytes:.2f}x")
if __name__ == "__main__":
test_w4a8()
运行这段代码,你会看到类似这样的输出:
FP16 vs W4A8 MSE: 0.000234
权重压缩比: 7.52x
注意:这里的压缩比看起来很高,是因为我们的层比较小,scale 开销占比相对大。在真实大模型中,W4A16 的压缩比大约是 3.2x 左右。
8.2 W4A8 推理流程示意
W4A8 的完整推理流程可以用下面这张图来理解:
输入 token ids
│
▼
Embedding(FP16)
│
▼
量化激活 x → INT8(per-token)
│
▼
加载 4-bit 权重 + group scales
│
▼
INT8/INT4 GEMM(Tensor Core 加速)
│
▼
反量化:y = scale_x * scale_w * C_int32
│
▼
重复 N 层 attention + FFN
│
▼
LM Head(FP16)
│
▼
输出 logits → sampling → token
九、常见误区与小结思考
9.1 常见误区
误区 1:GPTQ-Int4 就是 W4A8
不对。GPTQ-Int4 默认激活是 FP16,所以是 W4A16。只有当激活也量化到 8-bit 时,才是 W4A8。
误区 2:group_size 越小越好
group_size 小确实精度更高,但 scale 的存储开销也更大。group_size=32 的 scale 开销是 group_size=128 的 4 倍。128 通常是精度和显存的最佳平衡点。
误区 3:W4A8 一定比 W4A16 快
不一定。虽然 INT8 计算吞吐更高,但激活量化也有开销,而且 INT4 解包也需要时间。在很多场景下,W4A16 的推理速度反而更快。W4A8 的主要优势是显存更省,不是速度更快。
误区 4:所有层都应该量化
不对。像 embedding、lm_head、注意力的某些层对精度比较敏感,通常保持 FP16 效果更好。GPTQ 的 dynamic 配置就是用来排除这些层的。
误区 5:MLC-LLM 的 convert 和 compile 是一回事
不是。convert 是转换权重数据格式,compile 是编译计算图和 kernel。前者处理数据,后者处理计算逻辑。
9.2 小结
- W4A8 = 4-bit 权重 + 8-bit 激活,是 W4A16 的进一步激进压缩方案,用精度换显存和吞吐。
- GPTQ-Int4 是 W4A16 的权重实现 ,常用配置是
group_size=128、sym=true、desc_act=false。 - Qwen3.5-35B-A3B 是 MoE 模型,256 个专家、每 token 激活 8 个,兼顾参数量和计算效率。
- MLC-LLM 导出三步走 :
gen_config→convert→compile,分别处理配置、权重和计算图。 - 推理接口两种选择 :
ChatModule简单易用,MLCEngine支持流式输出,更适合生产环境。
9.3 思考题
-
为什么 GPTQ-Int4 通常保持激活为 FP16,而不是直接做 W4A8?(提示:考虑激活的动态范围和量化误差累积)
-
group_size=128相比group_size=32,在精度和显存开销上如何权衡? 什么场景下你会选择更小的 group_size? -
MLC-LLM 的
convert和compile两步分别做了什么?为什么需要分开? 能否合并成一步? -
如果激活也量化到 8-bit,per-token 和 per-tensor 哪种粒度更适合 LLM 生成阶段?为什么?
-
对于 MoE 模型,router(专家选择器)的精度对整体效果影响大吗?量化时是否应该保护 router 不被量化?
下一篇预告:我们将学习 KV Cache 量化技术,探索如何让大模型支持超长上下文推理。敬请关注!
如果本文对你有帮助,欢迎点赞、收藏、关注三连!有问题也可以在评论区留言讨论~