推理时,模型权重通常是最大的一块静态显存。 对一个 7B 模型,FP16 权重大约 14GB;如果权重压到 4 bit,理论权重主体约 3.5GB, 再加上 scale、zero point、packing metadata 和运行时 buffer。 这会直接影响能否单卡加载、能否留下更多显存给 KV Cache,以及 decode 阶段读权重时的带宽压力。

量化的基本动作是把浮点权重映射到整数格点。 反推理时,整数权重需要和 scale 一起恢复为近似浮点值,或在 mixed-precision kernel 中边乘边反量化。 LLM 权重量化常见的是 weight-only quantization:权重低 bit 存储,激活仍用 FP16/BF16。

toy symmetric quantization

import torch

def quantize_symmetric(x, bits=4, group_size=128):
    qmax = 2 ** (bits - 1) - 1
    qmin = -2 ** (bits - 1)
    flat = x.flatten()
    qs, scales = [], []

    for start in range(0, flat.numel(), group_size):
        g = flat[start:start + group_size]
        scale = g.abs().max().clamp_min(1e-8) / qmax
        q = torch.round(g / scale).clamp(qmin, qmax).to(torch.int8)
        qs.append(q)
        scales.append(scale)

    return torch.cat(qs), torch.stack(scales)

def dequantize_symmetric(q, scales, shape, group_size=128):
    chunks = []
    for i, scale in enumerate(scales):
        chunks.append(q[i * group_size:(i + 1) * group_size].float() * scale)
    return torch.cat(chunks).reshape(shape)

直接 round-to-nearest 通常不够好。 GPTQ 和 AWQ 都是 post-training quantization,不需要重新训练完整模型, 但会用少量校准数据判断哪些误差更重要。 粗略说,GPTQ 试图逐层最小化量化后的重构误差;AWQ 则用激活分布识别重要通道, 通过缩放保护 salient weights,尽量让 4 bit 权重保留指令模型的质量。

AutoGPTQ 是理解 GPTQ 流程的好入口:准备校准样本,配置 bits/group_size, 加载 FP16 模型,执行 model.quantize(examples),保存量化权重。 真实项目里要注意维护状态、模型支持表、CUDA/PyTorch 版本和推理 kernel 是否匹配。

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

pretrained_model_dir = "facebook/opt-125m"
quantized_model_dir = "opt-125m-gptq-4bit"

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_dir, use_fast=True)
examples = [
    tokenizer("Quantization compresses LLM weights for inference."),
    tokenizer("Calibration samples should look like serving prompts."),
]

quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=False,  # True 可能更准,但推理/兼容性需验证
)

model = AutoGPTQForCausalLM.from_pretrained(
    pretrained_model_dir,
    quantize_config,
    device="cuda:0",
)
model.quantize(examples)
model.save_quantized(quantized_model_dir, use_safetensors=True)
tokenizer.save_pretrained(quantized_model_dir)

llama.cpp 的常见流程是两步: 先把 Hugging Face 模型转换为高精度 GGUF,再用 llama-quantize 生成 Q4/Q5/Q8 等量化 GGUF。这个路线特别适合本地推理、CPU/Metal/Vulkan 或边缘设备部署。

# 1. 安装 Python 依赖
python3 -m pip install -r requirements.txt

# 2. 从 Hugging Face repo 转成高精度 GGUF
python convert_hf_to_gguf.py \
  --outfile model-bf16.gguf \
  --outtype bf16 \
  --remote meta-llama/Llama-3.2-1B-Instruct

# 3. 量化成常用 Q4_K_M
./build/bin/llama-quantize \
  model-bf16.gguf \
  model-Q4_K_M.gguf \
  Q4_K_M

# 4. 运行量化模型
./build/bin/llama-cli \
  -m model-Q4_K_M.gguf \
  -p "Explain weight quantization in one paragraph." \
  -n 128

量化评估要同时看三类指标: 质量有没有明显下降,性能有没有真实提升,资源占用是否达成目标。 只看模型文件变小会漏掉最关键的问题:低 bit 权重可能造成困惑度上升、输出格式不稳, 也可能因为 kernel 不匹配而没有速度收益。

报告模板

model: Llama-3.2-1B-Instruct
baseline: bf16
quantized: Q4_K_M / GPTQ-4bit-g128
calibration:
  samples: 128
  max_seq_len: 2048
  source: mixed chat prompts

quality:
  ppl_fp16: 8.42
  ppl_quant: 8.83
  golden_pass_rate_fp16: 94.0%
  golden_pass_rate_quant: 92.5%

performance:
  peak_vram_fp16: 3.1 GB
  peak_vram_quant: 1.4 GB
  tpot_fp16: 28.4 ms
  tpot_quant: 17.9 ms

decision:
  accept: yes
  reason: quality drop acceptable, memory target met, decode faster

1. 为什么 weight-only quantization 能降低 decode 阶段的内存带宽压力?
2. scale、zero point、group size 分别控制什么?group size 变小会带来什么代价?
3. GPTQ 为什么需要校准样本?它试图最小化什么误差?
4. AWQ 为什么要看 activation 而不只看 weight magnitude?
5. 量化模型上线前,你会用哪些质量、性能和资源指标做验收?