【大模型基础设施工程】14：量化工程 —— INT8 / FP8 / FP4 / AWQ / GPTQ 怎么选

系列第 14 篇。上一篇 vLLM / SGLang / TensorRT-LLM / TGI 对比了推理引擎的调度与吞吐，本篇深入推理优化的另一条主轴 —— 量化（Quantization）：把模型权重、激活、KV Cache 从 FP16/BF16 压到 FP8、INT8、FP4、INT4，乃至 1.58-bit，换来显存、带宽和成本上的收益。

量化是 2023 年以来 LLM 推理侧最显著的工程变量之一。一块 80 GB 的 H100 放不下 Llama-3-70B BF16（140 GB），但 FP8 只要 70 GB、INT4 只要 35 GB；decode 阶段受显存带宽限制，权重字节数减半，单 token 延迟的理论下界也减半。本篇按”为什么 → 数据类型 → 算法 → 粒度 → 硬件 → 引擎 → 实操”的顺序把量化拆开。

先给不想读完全文的读者一张速查（理由见第十二节的经验法则）：

选完位宽，还要按第十节第 6 小节的方法在自己的评测集上实测一遍，量化带来的质量损失因模型、任务和校准集而异。如果你关心的是量化之外的推理优化，调度与显存管理见 PagedAttention 与 Continuous Batching，量化 kernel 的实现细节见 GPU 算子工程：量化与多精度算子。

一、为什么量化：显存、带宽、成本

1.1 显存账：参数量 × 位宽

对一个参数量为 \(N\) 的模型，权重显存 \(= N \times b / 8\) 字节，其中 \(b\) 是每个参数的比特数。以 Llama-3-70B 为例：

加上 KV Cache、activation buffer、CUDA graph，实际占用要再加 10%–30%。但数量级结论很清晰：BF16 → FP8 节省 50%，BF16 → INT4 节省 75%。

1.2 带宽账：decode 阶段 memory-bound

在自回归 decode 阶段，每生成一个 token 要把全部权重从 HBM 读一遍（prefill 不同，是 compute-bound）。Roofline 模型下：

\[ T_{\text{decode}} \approx \frac{\text{model\_size}}{\text{HBM\_BW}} \]

H100 SXM 的 HBM3 带宽约 3.35 TB/s。Llama-3-70B： - BF16：140 GB / 3.35 TB/s ≈ 42 ms/token（单卡理论下界） - FP8：70 GB / 3.35 TB/s ≈ 21 ms/token - INT4：35 GB / 3.35 TB/s ≈ 10.5 ms/token

这解释了为什么量化 decode 能近似线性提速 —— 带宽减半，延迟下界减半。实际加速达不到理想值：反量化开销、kernel 实现效率、batch 大小和 KV Cache 读取都会吃掉一部分，需要在目标硬件上实测。

1.3 成本账：更大 batch、更长上下文、更便宜的卡

权重压下去后省出来的显存可以用来：

• 扩 batch：KV Cache 预算变大，continuous batching 的 max_num_seqs 可以从 128 提到 512；
• 加长上下文：32k → 128k，对长文档 / Agent 工作流收益大；
• 降级硬件：70B INT4 可以塞进 A10G（24 GB × 2）或 L40S（48 GB），推理单价可能降一个数量级；
• 节省出口管制下的算力：H20、910B、4090D 环境里，量化是唯一可行的大模型方案。

二、浮点与整数数据类型

2.1 传统浮点：FP32 / FP16 / BF16

IEEE 754 浮点结构：符号位 S | 指数 E | 尾数 M，数值为 \((-1)^S \times 2^{E - \text{bias}} \times 1.M\)。

BF16 保留 FP32 的指数范围，牺牲尾数，解决 FP16 训练中常见的溢出问题，是当前训练的主流；FP16 精度略高但动态范围窄，训练需要 loss scaling。TF32 是 Ampere 起 Tensor Core 内部的 19-bit 格式，用户侧仍写 FP32。

2.2 FP8：Hopper/Ada 引入，两种变体

Hopper（H100 / H200 / H20）和 Ada（L40S）原生支持 FP8 Tensor Core，吞吐是 BF16 的 2 倍。两种变体：

E4M3 精度高但范围窄，E5M2 相反。NVIDIA Transformer Engine（TE） 会在训练中自动做 per-tensor scaling：统计 amax，乘 scale 后转 FP8，反向用 E5M2。

2.3 FP6：Blackwell 新增

Blackwell（B100 / B200 / GB200）新增 FP6 Tensor Core，位宽在 FP8 和 FP4 之间。OCP MX 规范定义了 E2M3 和 E3M2 两种 FP6 元素格式；更早的 FP6-LLM 工作（Xia et al., 2024，在 A100 上用软件 kernel 实现 FP6 推理）采用的是 E3M2。FP6 适合”INT4 精度不够、FP8 显存太大”的中间地带。

2.4 FP4：Blackwell Tensor Core 原生

Blackwell 支持 FP4（E2M1）：1 符号 + 2 指数 + 1 尾数，可表示 \(\{\pm0, \pm0.5, \pm1, \pm1.5, \pm2, \pm3, \pm4, \pm6\}\) 共 16 个值。B200 的 FP4 Tensor Core 吞吐达到 FP8 的 2 倍、BF16 的 4 倍，官方宣称 GPT-MoE 1.8T 推理吞吐是 H100 的 30 倍主要来自 FP4 + NVLink72。

2.5 微缩放（MX）格式：OCP 标准

2023 年 Open Compute Project（AMD、ARM、Intel、Meta、Microsoft、NVIDIA、Qualcomm）联合发布 Microscaling (MX) Formats v1.0：

• 共享 scale：每 32 个元素共享一个 E8M0（8-bit 指数）的 scale，再加上元素自身的低精度浮点；
• MXFP8 / MXFP6 / MXFP4 / MXINT8：元素分别是 FP8 / FP6 / FP4 / INT8；
• 每 32-元素块的总位宽 = \(32 \times b + 8\)，等价有效位宽 \(b + 0.25\)。

MX 格式把 per-block scaling 硬件化，Blackwell Tensor Core 直接消费 MXFP8/FP6/FP4，省去 CUDA kernel 手动做 dequant。NVIDIA 在 Blackwell 上还定义了自家的 NVFP4：每 16 个 FP4 元素共享一个 E4M3 的 scale，再叠加一个 per-tensor 的 FP32 scale，块更小、scale 精度更高，用来缓解 MXFP4 的精度损失。开源模型里已有直接以 MXFP4 发布权重的例子：OpenAI 在 2025 年 8 月发布的 gpt-oss 系列，MoE 层权重即为 MXFP4。

2.6 INT8 / INT4

纯整数量化，最简单的线性映射：

\[ q = \text{round}\left(\frac{x}{s}\right) + z, \quad x \approx s \cdot (q - z) \]

其中 \(s\) 是 scale、\(z\) 是 zero-point。对称量化 \(z=0\)，非对称量化 \(z \neq 0\)。INT8 范围 \([-128, 127]\)，INT4 范围 \([-8, 7]\)。INT 量化在消费卡（4090、3090）、昇腾、AMD MI250 等没有 FP8 的硬件上仍是首选。

2.7 各数据类型位布局

三、PTQ：训练后量化

PTQ（Post-Training Quantization） 不更新权重梯度，只用少量校准数据（通常 128–512 条）统计分布、求 scale / 修正权重，几分钟到几小时完成，是生产部署的主流路径。

3.1 朴素 RTN（Round-To-Nearest）

最简单：对每层权重独立求 \(s = \max(|W|) / q_{\max}\)，round 到最近的量化格点。INT8 下精度通常可接受，INT4 下 LLM 质量显著下降，需要更聪明的算法。

3.2 GPTQ：基于 Hessian 的逐列最小二乘

GPTQ（Frantar et al., ICLR 2023） 把权重量化建模为带约束最小二乘：

\[ \min_{\hat W} \| W X - \hat W X \|_F^2, \quad \hat W \in \text{QuantGrid} \]

其中 \(X\) 是校准激活。GPTQ 按列（或分组）贪心量化，每量化一列用剩余列补偿误差，依赖 Hessian \(H = 2 X X^\top\) 的 Cholesky 分解：

1. 计算 \(H^{-1}\)；
2. 按列遍历 \(W\)：当前列 \(w_j\) 量化为 \(\hat w_j\)，误差 \(\epsilon = (w_j - \hat w_j) / [H^{-1}]_{jj}\)；
3. 把 \(\epsilon\) 均摊到剩余未量化列：\(w_k \leftarrow w_k - \epsilon \cdot [H^{-1}]_{jk}\)（\(k > j\)）。

对 175B 模型 4-bit 量化约需 4 小时单卡 A100。GPTQ 是 INT4 权重量化的事实标准之一，AutoGPTQ / GPTQModel 库覆盖 Llama / Qwen / Mixtral 等主流结构。

3.3 AWQ：Activation-aware Weight Quantization

AWQ（Lin et al., MLSys 2024） 观察：权重并非同等重要，被大激活通道乘的权重列更敏感。做法：

• 对每个 in-channel \(c\) 乘缩放 \(s_c\)，对应激活除以 \(s_c\)： \[ Y = (W \cdot \text{diag}(s)) \cdot (\text{diag}(s)^{-1} X) = W' X' \]
• 只量化 \(W'\)，激活不量化；
• \(s_c\) 通过网格搜索最小化 \(\|W'_q X' - W X\|\)。

AWQ 不依赖反向传播，也不做逐列的误差补偿，只需前向校准加一次缩放搜索，量化耗时通常短于 GPTQ；论文在 LLaMA、OPT 等模型的 INT4（g128）设置下报告 AWQ 的困惑度优于 RTN 与 GPTQ，具体数值见原文表格。AutoAWQ 曾是最常用的 AWQ 实现，项目已在 2025 年宣布停止维护，维护者推荐迁移到 vLLM 项目的 llm-compressor；已有的 AWQ 权重格式仍被 vLLM、TensorRT-LLM 等引擎支持。

3.4 SmoothQuant：权重 / 激活联合平滑

SmoothQuant（Xiao et al., ICML 2023） 针对 W8A8（权重激活都 INT8）量化：激活 outlier 集中在少数通道，直接量化会严重掉点。SmoothQuant 引入逐通道缩放 \(s_c\)：

\[ Y = (X / \text{diag}(s)) \cdot (\text{diag}(s) W) = \tilde X \tilde W, \quad s_c = \max(|X_c|)^\alpha / \max(|W_c|)^{1-\alpha} \]

参数 \(\alpha\)（常取 0.5）把量化难度从激活转移一部分到权重，两者都能较平滑地 INT8，无 outlier。SmoothQuant 是 NVIDIA TensorRT-LLM INT8 的默认路径之一。

3.5 SpinQuant / QuaRot：旋转矩阵消除 outlier

2024 年涌现的一类方法，观察：outlier 来源于 Transformer residual stream 的 few-channel 集中，用正交旋转矩阵 \(R\)（Hadamard 或学习得到）做变换：

\[ \hat W = R_1^\top W R_2, \quad \hat X = R_1 X \]

在数学上等价（\(R^\top R = I\)），但旋转后的激活近似高斯，outlier 被打散，可以干净地量化到 INT4 / FP4。

• QuaRot（Ashkboos et al., 2024）：用 Hadamard 旋转，计算量 \(O(n \log n)\)，支持 W4A4 KV4 端到端 INT4；
• SpinQuant（Meta, 2024）：旋转矩阵作为可学习参数，在 Stiefel 流形上用少量校准数据优化；论文报告在 W4A4KV4 设置下，LLaMA-2 7B 的零样本推理任务平均准确率与全精度的差距缩小到 2.9 个百分点。

旋转法目前是把 INT4 / FP4 激活量化做到实用的关键技术。Meta 在 2024 年 10 月发布的 Llama 3.2 1B / 3B 量化版就用到了 SpinQuant（另一套为 QAT + LoRA），方案是 4-bit 分组权重加 8-bit 动态激活，面向手机等端侧设备。

四、QAT：量化感知训练

PTQ 在 INT4 以下、或权重激活都量化（W4A4、W4A8）时经常掉点。QAT（Quantization-Aware Training） 在训练过程中插入 fake-quant 算子，梯度穿透（STE，Straight-Through Estimator）保持可微，让模型”学会”适应量化误差。

4.1 LLM-QAT（Meta, 2023）

在 Llama 基座上做 W4A8KV4 的 QAT：用原模型自己生成 100k 条蒸馏数据（避免依赖外部语料），KL 蒸馏 + 交叉熵，几千步训练即可收敛。

4.2 BitDistiller

在 SFT 阶段同步做 INT2/INT3 量化训练，结合 self-distillation，把 Llama-2-7B 压到 2-bit 仍保持可用质量。

4.3 BitNet 与 BitNet b1.58

BitNet（Microsoft, 2023）：1-bit 权重（\(\{-1, +1\}\)）从零训练 Transformer，论文报告其困惑度与 FP16 基线的差距随模型规模扩大而缩小，并给出了相应的缩放曲线。

BitNet b1.58（Microsoft, 2024）：权重取三值 \(\{-1, 0, +1\}\)，等效 \(\log_2 3 \approx 1.58\) bit。核心变化： - 权重 absmean 量化（每矩阵一个 scale）； - 激活 absmax 量化到 INT8； - 从头 QAT 训练（PTQ 无法得到三值）。

论文报告 3B 参数时困惑度与同规模 FP16 LLaMA 持平，并估算 70B 规模下推理速度约为 FP16 LLaMA 的 4.1 倍、显存约为其 1/7。Microsoft 随后开源了 CPU 推理框架 bitnet.cpp，并在 2025 年发布了从头训练的 BitNet b1.58 2B4T 模型；主要限制仍是必须从头训练，不能量化现有模型，落地多见于边缘设备和研究项目。

五、KV Cache 量化

对长上下文、大 batch 的推理场景，KV Cache 显存占比可能超过权重。以 Llama-3-70B（Grouped-Query-Attention、head_dim=128、kv_heads=8、80 层）为例，单 token KV = \(2 \times 80 \times 8 \times 128 \times 2\text{B} = 327.68 \text{ KB}\)；128k 上下文、batch=16 时 KV 总量 = \(128000 \times 16 \times 327.68 \text{KB} \approx 671 \text{ GB}\)（约 625 GiB），远超权重。量化 KV Cache 收益非常可观。

5.1 FP8 KV

NVIDIA H100 上 FP8 KV Cache 几乎无损，直接用 E4M3 per-tensor 或 per-token scaling，vLLM、TensorRT-LLM、SGLang 都有原生支持：

# vLLM
llm = LLM(model="Qwen/Qwen2.5-72B-Instruct",
          kv_cache_dtype="fp8_e4m3",
          calculate_kv_scales=True)

5.2 INT8 KV

INT8 KV 与 FP8 KV 的显存收益相同，适合没有 FP8 支持的硬件（A100、昇腾等）。常见做法是 per-token 或 per-head 的对称量化，vLLM、TensorRT-LLM、LMDeploy 都有实现，质量损失通常很小。

5.3 更低比特的 KV：KIVI / KVQuant

• KIVI（ICML 2024）：无需校准的 2-bit 非对称量化，Key 按通道（per-channel）量化、Value 按 token 量化，最近的一小段 token 保留全精度；
• KVQuant（NeurIPS 2024）：同样对 Key 做 per-channel 量化，并在 RoPE 之前量化 Key、为 outlier 单独保留稀疏的高精度值，目标是 3-bit 甚至更低，用于千万 token 级别的超长上下文。

Key 适合按通道量化，是因为少数通道的幅值长期偏大，按 token 量化会让这些通道挤占整个量化区间。4-bit 以下的 KV 对长上下文和数学类任务更敏感，工程上常与 FP8 / FP16 混合（最近的 token 用高精度、历史 token 用低比特），上线前必须在自己的长上下文评测集上验证。

5.4 实操：vLLM FP8 KV

from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Meta-Llama-3.1-70B-Instruct",
    quantization="fp8",          # 权重 FP8
    kv_cache_dtype="fp8_e4m3",   # KV FP8
    max_model_len=128000,
    tensor_parallel_size=2,
)
out = llm.generate(["解释 KV Cache 量化的带宽收益"],
                   SamplingParams(max_tokens=256))
print(out[0].outputs[0].text)

单机 2×H100 80GB：BF16 的 70B 权重就要 140 GB，两张卡几乎没有 KV 空间，通常要上 4 卡；FP8 权重约 70 GB，加上 FP8 KV，两张卡就能留出可观的 KV 预算。卡数减半后吞吐和延迟怎么变，取决于 batch 和上下文长度，需要按第十节的方法实测。

六、激活量化与 outlier 通道

6.1 LLM.int8() 的观察（Dettmers, 2022）

Dettmers 在 6.7B 规模首次观察到：极少数（≈0.1%）激活通道的幅值是其他通道的 100×–1000×，这些”outlier 通道”直接量化会毁掉数值精度。LLM.int8() 的解法简单粗暴：

• 按通道拆两路：outlier 通道走 FP16，其余走 INT8；
• 最后把两路结果相加。

这给 6.7B 以上模型带来了几乎无损的 INT8，代价是速度：拆分和合并两路计算的开销不小，论文中较小的模型用 LLM.int8() 反而比 FP16 慢，它的主要价值是省显存而不是提速。

6.2 outlier 从何而来

后续研究发现 outlier 与 residual stream 中几个”承载任务路由信息”的固定通道强相关，且随训练稳定。LayerNorm 的 scale 参数 \(\gamma\) 会放大这些通道，使 outlier 在更深层愈发明显。

6.3 对策谱系

七、量化粒度：per-tensor / per-channel / per-group / per-block

per-group 是 INT4 权重的主流，group_size=64 或 128 在精度和 scale 存储间平衡。per-block（MX） 是 Blackwell 起的硬件标配，scale 随数据流动，无需软件干预。

八、硬件支持矩阵

“dequant → FP16” 表示硬件不直接计算 INT4 × FP16 矩阵乘，kernel 要在寄存器里把 INT4 权重解压到 FP16 再上 Tensor Core。解压本身不省算力，收益全部来自少读的权重字节，所以 kernel 写得好不好决定了能拿到多少：早期的 AWQ / GPTQ kernel 加速有限，Marlin 这类专门为 batch 较小的 decode 优化的 INT4×FP16 kernel，按其作者公布的测量，在 batch 16 到 32 以内可以接近 4 倍的理想加速，batch 再大就回到计算受限。

这张表是按厂商公开资料整理的撰写时状态，未逐项实测；国产加速卡的数据类型支持随软件栈版本变化较快，选型前以厂商最新文档为准。

NVIDIA Transformer Engine 是 FP8 训练的官方路径，自动管理 per-tensor amax / scale / history；推理侧 vLLM、TensorRT-LLM 都集成了 TE 的 FP8 GEMM。

九、推理引擎的量化支持矩阵

矩阵反映撰写时各项目文档的状态，版本迭代很快，部署前以对应版本的文档为准。llama.cpp 一行需要单独说明：它不直接加载 AWQ / GPTQ 格式的权重，而是用自己的 GGUF 量化类型（见下一小节）；AWQ 的缩放可以在转换为 GGUF 之前先应用到 FP16 权重上。

9.1 llama.cpp 的 GGUF 量化体系

llama.cpp 的 GGUF 格式是 CPU / 小 GPU / Apple Silicon 的主流，提供一整套精细化量化级别：

Q4_K_M 是桌面 / Mac 跑 70B 最常见的选择：70B × 4.8 bit ≈ 42 GB，加上 KV Cache 和运行时开销，48 GB 以上的统一内存或显存比较从容；质量通常明显好于 Q3 档，但与 FP16 的差距因模型而异。

十、工程实操：AutoAWQ 量化 Qwen + 部署 vLLM

10.1 环境

pip install autoawq==0.2.6 vllm==0.6.3 transformers==4.45.0

10.2 AutoAWQ 量化脚本

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "Qwen/Qwen2.5-7B-Instruct"
quant_path = "./qwen2.5-7b-awq-int4"
quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM",
}

model = AutoAWQForCausalLM.from_pretrained(
    model_path, device_map="auto", safetensors=True
)
tok = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

# 校准数据：默认使用 AutoAWQ 内置的 pileval 数据集；
# 换成业务数据时传入字符串列表，建议至少 128 条、每条几百 token
model.quantize(tok, quant_config=quant_config, calib_data="pileval")
model.save_quantized(quant_path, safetensors=True)
tok.save_pretrained(quant_path)
print("AWQ done ->", quant_path)

校准数据不要只放几句短文本：AutoAWQ 会把样本拼接后切成固定长度的块，样本总 token 数太少时块数不足，缩放搜索的统计就不可靠。耗时取决于 GPU、校准集规模和模型结构。产物为 safetensors + quant_config.json：7B 的 INT4 权重本体约 3.5 GB，加上保持 FP16 的 embedding、lm_head 和 group scale，总体积约为 BF16 版本（约 15 GB）的三分之一到四成。

AutoAWQ 已停止维护，锁定上面的版本号可以复现；新项目可以改用 llm-compressor，它导出的权重同样能被 vLLM 加载。

10.3 GPTQ 脚本（对比）

from datasets import load_dataset
from gptqmodel import GPTQModel, QuantizeConfig

calib = load_dataset("allenai/c4", data_files="en/c4-train.00001-of-01024.json.gz",
                     split="train").select(range(256))["text"]

cfg = QuantizeConfig(bits=4, group_size=128, desc_act=True, sym=True)
model = GPTQModel.load("Qwen/Qwen2.5-7B-Instruct", cfg)
model.quantize(calib, batch_size=1)
model.save("./qwen2.5-7b-gptq-int4")

这段脚本另需 pip install gptqmodel datasets。上面的写法对应 GPTQModel 1.x 以后的接口（GPTQModel.load 加 quantize(calib_data)），更早的版本用 from_pretrained，以所装版本的 README 为准。GPTQ 需要逐层累积 Hessian 并做逐列误差补偿，显存峰值和耗时一般高于 AWQ；两者在不同模型、不同任务上互有胜负，按自己的评测集选。

10.4 vLLM 部署

python -m vllm.entrypoints.openai.api_server \
  --model ./qwen2.5-7b-awq-int4 \
  --quantization awq_marlin \
  --kv-cache-dtype fp8_e4m3 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.92 \
  --port 8000

awq_marlin 是 vLLM 把 AWQ 权重接到 Marlin INT4×FP16 kernel 上的实现（Marlin 由 IST Austria 的研究者开源），小 batch decode 明显快于早期的 AWQ kernel；具体倍数随 GPU 型号和 batch 大小变化。

10.5 TensorRT-LLM 部署（FP8）

TensorRT-LLM 的 FP8 量化走 examples/quantization/quantize.py（底层调用 NVIDIA ModelOpt 做校准），再用 trtllm-build 构建引擎。以下命令基于 TensorRT-LLM 0.1x 版本的 examples 目录，参数名在不同版本间有调整，以所用版本的文档为准：

# FP8 权重 + FP8 KV 校准，按 2 卡张量并行切分
python examples/quantization/quantize.py \
  --model_dir Qwen2.5-72B-Instruct \
  --dtype bfloat16 \
  --qformat fp8 --kv_cache_dtype fp8 \
  --calib_size 512 --tp_size 2 \
  --output_dir ./ckpt-fp8

# Engine 构建
trtllm-build --checkpoint_dir ./ckpt-fp8 \
  --output_dir ./engine-fp8 \
  --gemm_plugin auto --max_batch_size 64 --max_input_len 32768

# 运行
mpirun -n 2 python examples/run.py --engine_dir ./engine-fp8 \
  --tokenizer_dir Qwen2.5-72B-Instruct --max_output_len 256 \
  --input_text "解释 FP8 的 E4M3 与 E5M2 区别"

较新的 TensorRT-LLM 版本也可以跳过手动构建，直接用 trtllm-serve 加载 ModelOpt 导出的 FP8 checkpoint 起 OpenAI 兼容服务。

10.6 精度前后对比：评测方法与定性结论

量化前后必须实测对比，不能凭感觉选位宽。显存随位宽线性下降可以直接算（见 §1.1）；质量损失则要在固定评测脚本下跑一遍，常用三个口径：

• wikitext PPL：困惑度，对权重扰动最敏感，量化回归测试的首选信号；
• MMLU（5-shot）：知识 / 推理综合能力，反映”是否变笨”；
• GSM8K（strict）：数学链式推理，对低位宽更敏感，容易先掉。

评测时要锁定模型版本、评测框架（如 lm-evaluation-harness）与提示模板，量化前后只改权重 / KV 精度，其余保持一致，否则数字不可比。本文不附固定数表——不同模型、版本、校准集与评测脚本下绝对值差异很大，列一张脱离环境的表会误导选型。

从各家公开 recipe 与论文给出的方向性结论（具体数值以各自来源为准）：

• FP8（E4M3）权重 + FP8 KV：在 Hopper 上质量接近无损，显存约减半，是当前最稳的默认项（vLLM、TensorRT-LLM 的 FP8 量化文档；DeepSeek-V3 技术报告则说明 FP8 连大规模训练都能撑住）；
• W8A8 SmoothQuant：INT8 权重 + INT8 激活质量损失小（SmoothQuant 论文，ICML 2023）；
• INT4 AWQ（g128）：在多数模型上质量损失小于同位宽 GPTQ，是显存 / 质量平衡点（AWQ 论文，MLSys 2024）；
• INT4 KV / W4A4：长上下文与数学任务掉点明显，需谨慎评估，必要时用旋转法（QuaRot / SpinQuant）或 FP8 / INT4 混合 KV。

十一、精度 vs 速度权衡

十二、常见坑与经验法则

12.1 “量化后模型胡说八道”排查

• 校准集不匹配：用通用语料量化，业务是中文 / 代码，换成业务相关数据再跑一次；
• group_size 过大：INT4 g=256 掉点明显，改 128 或 64；
• outlier 层未跳过：embedding、lm_head、最后一层 norm 常跳过量化；
• kv_cache_dtype INT4 太激进：先只量化权重，再逐步量化 KV。

12.2 “量化后速度没变快”排查

• kernel fallback 到 FP16：Ampere / 非 Hopper 卡跑 FP8 会 emulate，反而变慢；
• batch 太大，compute-bound：量化主要降 decode 延迟，prefill 阶段收益小；
• max_model_len 过小：KV 占比低，省带宽价值不明显；
• 未用融合 kernel：AWQ 要跑在 awq_marlin、GPTQ 要跑在 exllamav2 / marlin。

12.3 经验法则

1. 有 Hopper 以上就 FP8：训练推理同构，精度无损，工程最省心；
2. A100 / Ampere 用 AWQ INT4 + FP16 KV：单卡跑 70B 的最佳组合；
3. 消费卡跑 70B：llama.cpp GGUF Q4_K_M；
4. B200 部署：FP8 起步最稳；MXFP4 / NVFP4 权重能再省一半显存和带宽，但对质量更敏感，先在自己的评测集上对比再上线；
5. 出口管制硬件（H20、910B）：FP8（H20） / INT8（910B）是主路径；
6. KV Cache 量化在长上下文才有价值：短上下文、小 batch 时 KV 占显存比例低，先量化权重；
7. 从 PTQ 开始，不够再 QAT：QAT 需要训练资源和数据，只有在 PTQ 的质量损失不可接受（通常是 4-bit 以下或 W4A4）时才值得。

十三、有公开文档的产业实践

这一节只列有官方技术报告或官方发布说明可查的做法，闭源厂商内部用什么精度没有公开资料，不在此列：

• DeepSeek：DeepSeek-V3 技术报告描述了大规模 FP8 混合精度训练，并公开了细粒度（tile / block 级）scaling 的做法；
• Meta：Llama 3.1 405B 官方同时提供 FP8 量化版本；Llama 3.2 1B / 3B 官方量化版采用 SpinQuant 与 QAT + LoRA 两套方案；
• OpenAI：2025 年 8 月开源的 gpt-oss 系列以 MXFP4 发布 MoE 层权重，是较早以 FP4 类格式作为官方发布格式的开源模型；
• Qwen 系列：官方在 Hugging Face 上同时发布 GPTQ-Int4 / Int8、AWQ 与 FP8 等量化版本；
• llama.cpp 生态：主流开源模型发布后，社区通常很快提供多个 GGUF 量化档位，GGUF 已是本地部署最常见的格式。

十四、小结

量化已从”压缩模型的 trick”演进为推理栈的一等公民：

• 数据类型：FP8 → FP6/FP4 → MX 格式，硬件和软件都在快速迭代；
• 算法：AWQ / GPTQ / SmoothQuant / SpinQuant 覆盖 PTQ 主要路径，QAT / BitNet 探索极限；
• KV Cache：和权重同等重要，FP8 KV 已是生产标配；
• 工程：AutoAWQ → vLLM、Transformer Engine → TensorRT-LLM、GGUF → llama.cpp 三套成熟组合；
• 决策：硬件 → 选位宽 → 选算法 → 选引擎 → 选粒度 → 选 KV 策略。

理解清楚上述每一环，结合业务 SLO（延迟、吞吐、质量、成本），才能做出正确的量化选型。下一篇 推测解码与 MTP 进入推理优化的”预测并行”维度 —— 它和量化基本正交，两者可以叠加使用。

按问题继续读：

• 量化省出来的显存怎么转化成吞吐：PagedAttention 与 Continuous Batching；
• 各推理引擎的量化支持和选型：vLLM / SGLang / TensorRT-LLM / TGI 对比；
• INT8 / FP8 GEMM、反量化和 per-channel scale 在 kernel 里怎么实现：GPU 算子工程：量化与多精度算子；
• 为什么 decode 受带宽限制、Tensor Core 的数据类型从哪来：GPU 计算入门——SM、Tensor Core、HBM、NVLink。

参考资料

1. Dettmers et al. LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale. NeurIPS 2022.
2. Frantar et al. GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers. ICLR 2023.
3. Lin et al. AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration. MLSys 2024.
4. Xiao et al. SmoothQuant: Accurate and Efficient Post-Training Quantization for LLMs. ICML 2023.
5. Ashkboos et al. QuaRot: Outlier-Free 4-Bit Inference in Rotated LLMs. NeurIPS 2024.
6. Liu et al. SpinQuant: LLM Quantization with Learned Rotations. arXiv 2405.16406, 2024（预印本，后发表于 ICLR 2025）.
7. Ma et al. The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits. Microsoft, 2024.
8. Xu et al. KIVI: A Tuning-Free Asymmetric 2-bit KV Cache Quantization. ICML 2024.
9. Hooper et al. KVQuant: Towards 10 Million Context Length LLM Inference. NeurIPS 2024.
10. OCP Microscaling Formats (MX) Specification v1.0, 2023.
11. NVIDIA Transformer Engine Documentation（FP8 / MXFP8）。
12. NVIDIA TensorRT-LLM 仓库与 Qwen / Llama 量化示例。
13. vLLM / SGLang / llama.cpp / AutoAWQ / GPTQModel 官方仓库与 README。
14. DeepSeek-AI DeepSeek-V3 Technical Report（FP8 训练实践）。
15. Meta Llama 3.1 / 3.2 Quantization Recipes。
16. Frantar et al. MARLIN: Mixed-Precision Auto-Regressive Parallel Inference on Large Language Models. arXiv 2408.11743, 2024；实现见 IST-DASLab/marlin 仓库。
17. Xia et al. FP6-LLM: Efficiently Serving Large Language Models Through FP6-Centric Algorithm-System Co-Design. USENIX ATC 2024.
18. OpenAI gpt-oss model card, 2025（MXFP4 权重格式说明）。
19. Liu et al. LLM-QAT: Data-Free Quantization Aware Training for Large Language Models. arXiv 2305.17888, 2023.
20. Wang et al. BitNet: Scaling 1-bit Transformers for Large Language Models. arXiv 2310.11453, 2023.

上一篇：vLLM / SGLang / TensorRT-LLM / TGI 对比 下一篇：推测解码与 MTP