【模型量化⑦】W4A8与GPTQ-Int4:极限压缩与MLC-LLM部署实战

【模型量化⑦】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=max⁡i∈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)

翻译成人话:

  1. 先把 INT8 激活和 INT4 权重做整数矩阵乘法,得到 INT32 累加结果。
  2. 最后乘以激活的 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 小结

  1. W4A8 = 4-bit 权重 + 8-bit 激活,是 W4A16 的进一步激进压缩方案,用精度换显存和吞吐。
  2. GPTQ-Int4 是 W4A16 的权重实现 ,常用配置是 group_size=128、sym=true、desc_act=false。
  3. Qwen3.5-35B-A3B 是 MoE 模型,256 个专家、每 token 激活 8 个,兼顾参数量和计算效率。
  4. MLC-LLM 导出三步走 :gen_config → convert → compile,分别处理配置、权重和计算图。
  5. 推理接口两种选择 :ChatModule 简单易用,MLCEngine 支持流式输出,更适合生产环境。

9.3 思考题

  1. 为什么 GPTQ-Int4 通常保持激活为 FP16,而不是直接做 W4A8?(提示:考虑激活的动态范围和量化误差累积)

  2. group_size=128 相比 group_size=32,在精度和显存开销上如何权衡? 什么场景下你会选择更小的 group_size?

  3. MLC-LLM 的 convert 和 compile 两步分别做了什么?为什么需要分开? 能否合并成一步?

  4. 如果激活也量化到 8-bit,per-token 和 per-tensor 哪种粒度更适合 LLM 生成阶段?为什么?

  5. 对于 MoE 模型,router(专家选择器)的精度对整体效果影响大吗?量化时是否应该保护 router 不被量化?


下一篇预告:我们将学习 KV Cache 量化技术,探索如何让大模型支持超长上下文推理。敬请关注!


如果本文对你有帮助,欢迎点赞、收藏、关注三连!有问题也可以在评论区留言讨论~

相关推荐
千寻技术帮26 分钟前
50055_基于AI的互帮互助小程序(源码+文档+数据库脚本+部署教程)
数据库·人工智能·小程序·毕业设计·springboot·课程设计
天树星智源39 分钟前
KV 剪枝的同一个误差,模型确定时只改 1.4% 的 token,不确定时改 65%:接上不确定性,AIME25 端到端快 1.27 倍
人工智能·大模型
AI英德西牛仔42 分钟前
PC 用户的效率革命:腾讯元宝导出 Word 指令与“AI 导出鸭”的底层逻辑
人工智能·word·excel·deepseek·ai导出鸭
Flynn Liang2 小时前
多智能体协同不再复杂:Redis Stream 消费者组、幂等与故障恢复
数据库·人工智能·redis·缓存·ai agent·智能体
Decay__10 小时前
PostgreSQL 数据库全栈运维实战系列 — 合集索引(24 篇)
运维·数据库·sql·mysql·架构
VIP_CQCRE10 小时前
GPT Image 2.6 商品图换背景后悬浮?接触阴影、透明区域与反射验收
图像处理·人工智能·ai·电商
泯泷11 小时前
别再傻傻地喂文件了,大厂都在偷偷给AI建这种“专属图书馆”
人工智能
oak隔壁找我11 小时前
一款运行在 DSH(DeepSeek Harness)中的类 Postman HTTP 接口调试插件
人工智能·程序员
高洁0111 小时前
数字孪生与计算机视觉:让机器看懂现场
人工智能·python·机器学习·transformer·迁移学习