QAT 深度拆解：大模型时代，量化感知训练到底还值不值得做？

本文不是 QAT 入门教程，也不是量化方法大拼盘。它试图回答一个在工程实践中被反复追问的问题：在 PTQ 越来越强、原生低比特训练开始出现的今天，QAT 到底处在什么位置？什么场景该用，什么场景别碰？

从一个反直觉现象说起

2025 年 4 月，Google 发布了 Gemma 3 的 QAT checkpoint。做法很简单：在已经训好的全精度模型上，跑大约 5000 步量化感知训练，用非量化 checkpoint 的输出概率作为蒸馏目标。就这么多。

结果是：int4 量化后的精度损失被减少了 54%。27B 模型量化到 int4 后可以跑在一张消费级 RTX 3090 上，12B 可以跑在笔记本 RTX 4060 的 8GB 显存里，1B 可以直接跑在手机上。

5000 步。连预训练总步数的万分之一都不到。

这就引出了一个矛盾：如果 QAT 这么"便宜"又有效，为什么绝大多数开源 LLM 都只发布 PTQ 版本——GPTQ、AWQ、GGUF——而不做 QAT？Hugging Face 上成千上万的量化模型，几乎全是 PTQ。

反过来说：如果 PTQ 已经够好了，Google 为什么还要特意做 QAT？Apple 为什么要发论文研究 QAT 的计算最优分配比例？NVIDIA 为什么要搞出一整套 QAT + 蒸馏（QAD）的流程？

更让人困惑的是：做过 QAT 的团队，很多反而会劝别人"别轻易碰这个东西"。

这些矛盾不是因为 QAT 好或不好，而是因为 QAT 处在一个非常精确的价值区间——它正好卡在"PTQ 不够但从头训又太贵"的那条缝里。理解这条缝的宽度、位置和边界，就是理解 QAT 在今天到底值不值得做。

一、QAT 到底在优化什么

1.1 先说清楚 PTQ 的局限

要理解 QAT 为什么存在，得先搞清楚 PTQ 到底在做什么、以及它在哪里力不从心。

PTQ（Post-Training Quantization）的逻辑很直接：拿一个已经训好的模型，用一小批 calibration 数据跑一遍前向传播，统计每一层权重和激活的分布范围，然后找一组最优的 scale 和 zero-point，把 FP16/BF16 的值映射到 INT8 或 INT4 的整数格子上。

关键在于：PTQ 不会修改权重本身。它只是在已有的权重分布上找一个"最不坏"的映射方案。权重是什么样就是什么样，PTQ 只能选怎么压缩、不能改被压缩的内容。

在高比特（W8A8）下，这通常够用。8-bit 有 256 个离散等级，对于大多数权重分布来说，量化噪声相对信号幅度很小——相当于给每个权重加了一个很微弱的随机扰动，模型对此有天然的鲁棒性。

但当你把比特数压到 4-bit（只有 16 个离散等级）甚至更低时，问题就变了。量化格子太稀疏，很多本来不同的权重值被迫映射到同一个整数上——信息丢失从"可忽略的噪声"变成了"结构性的精度损伤"。这时候，不管你的 calibration 数据选得多好、scale 算得多精确，PTQ 能做到的精度恢复都有一个硬上限：你不能通过更好的映射来补偿被映射对象本身不适合被映射这个事实。

打个比方：PTQ 像是把一幅细腻的油画强行缩小到 64×64 像素。你可以选最好的下采样算法——双线性、Lanczos、面积平均——但画本身的笔触、纹理、色彩渐变就是为高分辨率设计的，再好的算法也救不回来。

QAT 做的事情完全不同。它让画家在画的时候就知道最终画布只有 64×64，于是画家会用更大的色块、更简化的构图、更高对比度的配色——最终的画在 64×64 上看起来反而比那幅"被缩小的精细油画"更清晰。

1.2 QAT 的核心命题

QAT（Quantization-Aware Training）的核心不是"模拟部署环境"，虽然很多介绍文章这么说。更准确的表述是：QAT 让模型在训练过程中主动重新组织自己的权重，使得量化后的离散表示能最大限度地保留对任务关键的信息。

具体来说，QAT 在训练的前向传播中插入"fake quantization"操作——把权重和/或激活值先量化到目标精度（比如 INT4），再反量化回 FP16，然后用这个"被量化污染过的"值继续计算。反向传播时，梯度基于这些污染过的值计算，但更新的是底层的全精度权重。

这意味着训练循环的每一步，模型都在做一件事：在量化噪声存在的情况下，调整全精度权重使得最终 loss 最小。经过足够多步的优化，权重会自发地向"量化友好"的方向迁移——分布变得更集中、更适合均匀量化、敏感区域的信息冗余度更高。

1.3 "可恢复精度"到底从哪来

很多人觉得 QAT 的精度恢复像是某种魔法——明明信息被量化压缩了，怎么训一训就回来了？精度到底从哪来的？

答案来自三个层面：

第一，权重分布的主动调整。 QAT 后的权重分布会跟训练前明显不同。直方图会变得更集中、更接近均匀分布或者更集中在量化格点附近。这不是巧合——优化器在持续惩罚那些"落在两个格点之间"的权重值，因为它们在量化时会被 round 到一个可能完全错误的值。训练几千步后，大部分权重会自然地靠近某个量化格点。

第二，scale 和 zero-point 的联合优化。 在 PTQ 中，scale 和 zero-point 是通过 calibration 数据的统计量一次性算出来的。在 QAT 中，特别是使用 LSQ（Learned Step Size Quantization）或类似方法时，scale 本身也是可训练参数，跟权重一起被梯度优化。这意味着量化格子的位置和密度也在不断调整，最终找到一个全局更优的配置。

第三，模型的全局自适应。 这一点最微妙也最重要。当某一层的权重被量化损伤后，后续层会通过训练部分补偿这个损伤。整个模型作为一个整体，在"有量化噪声"的条件下重新找到了一个不同但有效的解。这不是某一层变好了，而是整个模型找到了一条在低精度约束下依然可行的路径。

这就是为什么 Google 只用 5000 步 QAT 就能显著提升精度——5000 步足够让权重分布做出关键调整，尤其是当你还用了蒸馏 loss 来引导调整方向的时候。

二、核心机制：fake quant、STE 和可学习参数

2.1 Fake Quantization 的具体操作

量化的数学表达不复杂。对于均匀量化，一个值 x 被量化的过程是：

其中 $s$ 是 scale（步长），$z$ 是 zero-point（零点偏移），$q_{min}$ 和 $q_{max}$ 是目标比特数决定的范围（比如 INT4 对称量化的范围是 $[-8, 7]$）。

所谓"fake quantization"，就是在训练的前向传播中执行上面这个操作——把 $x$ 变成 $x_{dq}$——但不真的把数据类型转成整数。值在形式上还是 $FP16/BF16$，但它只能取量化格子上的离散值。

为什么叫"fake"？因为真正的整数算术并没有发生。真正的 INT4 推理是在部署时由硬件执行的。训练时只是模拟了量化带来的精度损失。

对模型来说，每一层看到的输入和权重都经过了这道"量化-反量化"处理，携带了量化噪声。模型是在一个"每时每刻都有量化误差存在"的世界里学习。这跟 PTQ 的本质区别就在这里：PTQ 是在一个干净的世界里训完，然后突然把模型扔进一个有噪声的世界；QAT 从一开始就让模型在噪声中训练。

2.2 STE：这个粗暴近似为什么居然有效

fake quantization 的最大技术难题不在前向传播——前向传播就是一串确定性的计算。难在反向传播。

round() 函数不可微。严格来说，它的导数在整数点为 $0$（函数值不变），在非整数点则不存在（函数值有跳变）。如果你老实地用 round 的真实梯度，那反向传播在量化节点处就断掉了——没有梯度能传回去，权重没法更新。

Straight-Through Estimator（STE）的做法极其简单粗暴：在反向传播时，假装 round() 不存在，直接把梯度原样传回去。数学上就是令 $∂round(x)/∂x = 1$。

这在理论上完全不严谨。你给优化器的梯度跟真实梯度不一致，优化器拿到的是一个"骗"它的信号。按理说这应该导致优化方向错误、训练不收敛。

但工程上，STE 在中高比特（4-bit 及以上）下工作得出奇地好。原因不深奥：

当量化比特数为 b 时，相邻两个量化格点之间的间距大约是信号范围的 $1/2^b$。对于 4-bit，这个间距是信号范围的 1/16——每个值被 round 时最多偏移信号范围的 1/32。这个偏移量相对于权重值本身足够小，STE 引入的梯度偏差也相应很小。优化器拿到的虽然是一个近似梯度，但这个近似已经足够好，不会让优化方向走偏太多。

问题出在低比特。当量化降到 2-bit（只有 4 个格点），round 造成的偏移可以达到信号范围的 1/4 甚至更大。此时 STE 的"假装 round 不存在"假设严重失真——真实的梯度方向跟 STE 给出的方向可能差别很大。

这不是理论推导，而是有工程证据的。SingleQuant（2025）的研究直接指出：STE 在 Stiefel 流形上引入了非光滑性和梯度噪声，导致类似 SpinQuant 这样的方法在 2-bit 量化下训练速度极慢、效果不稳定。它们的解决方案是绕开 STE，用闭式的 Givens 旋转来替代梯度优化——不依赖梯度回传，自然就不受 STE 限制。

BitNet b1.58 的做法更激进：权重只有 ${-1, 0, +1}$ 三个值，round 造成的信息损失是最大化的。但它通过从头训练（而不是从全精度模型微调）、使用 STE 但配合特殊的 weight decay 策略和 learning rate schedule，让训练在 ternary 约束下仍然收敛。这说明 STE 在极低比特下不是完全不能用，但需要整个训练 recipe 的重新设计。

对工程实践的指导意义是：

• 4-bit 及以上的 QAT，STE 基本够用，按常规训练方法走就行
• 3-bit 到 2-bit，STE 开始出问题，需要配合额外技巧（progressive quantization、特殊的 LR、gradient clipping）
• 1-bit / ternary，STE 需要完全不同的训练范式支撑

2.3 Scale、Zero-Point 和 Clipping 的工程角色

量化不只是 round。在 round 之前，你需要把浮点值映射到整数范围内，这就是 scale 和 zero-point 的工作。

Scale 决定了量化格子的"密度"。scale 越大，能表示的值域越宽，但格点之间的间距也越大，精度越低。scale 越小，精度越高，但值域越窄，超出范围的值会被 clamp（截断）到边界——这就是 clipping。

Zero-point 决定了格子的"位置"。对称量化（zero-point = 0）更简单、硬件实现更高效；非对称量化能更好地覆盖偏斜分布，但会增加计算开销。

Clipping 的取舍是 QAT 中一个微妙但重要的决策。如果 scale 设得太大以覆盖所有值（包括 outlier），那大部分正常值只能用很少的格点表示，精度很差。如果 scale 设得较小以提高正常值的精度，outlier 就会被截断到边界，引入大的量化误差。

在 PTQ 中，这个取舍通过 calibration 一次性决定——通常用 min-max、percentile、或 MSE 最优化等方法。决定之后就不再改变。

在 QAT 中，scale（有时也包括 zero-point）可以作为可训练参数参与梯度更新。LSQ（Learned Step Size Quantization）是最经典的方案：它推导出 scale 的梯度公式，让 scale 在训练中不断调整，找到能让整体 loss 最小的值。

EfficientQAT（ACL 2025）把这个思路推到了极致：它的第二阶段（E2E-QP）冻结所有模型权重，只训练量化参数（scale 和 zero-point） 。这个做法的训练成本极低——因为大部分参数不更新，内存和计算开销都很小——但效果仍然显著，特别是在 weight-only 量化场景下。

这给出了一个重要的工程启示：QAT 不一定要做全参数训练。 如果你的预算有限，"只训量化参数"已经比纯 PTQ 好很多，而成本可能只增加 10%-20%。

---

三、从 CNN 到 LLM：游戏规则变了

3.1 CNN 时代的 QAT 为什么相对"干净"

量化感知训练不是 LLM 时代才有的概念。它最早在 CNN 分类模型上被系统研究——Google 的 Jacob et al. 在 2018 年形式化了这套方法，后来 TensorFlow Lite 和 PyTorch 都提供了成熟的 QAT 工具链。

在 CNN 上做 QAT 是相对"干净"的工作：

• 卷积核的权重分布通常比较均匀，没有极端的 outlier
• 激活值经过 ReLU 后是非负的，分布规律且有界
• 模型体量小——MobileNet 只有几 MB，ResNet-50 也不过百 MB——完整的 QAT 训练用一张 GPU 几个小时就能搞定
• 部署目标明确：TFLite → 手机 DSP、ONNX → 嵌入式加速器
• 工具链完善：TensorFlow Model Optimization Toolkit、PyTorch 的 torch.quantization 提供了从 fake quant 插入到模型导出的全链路支持

在这个背景下，QAT 几乎是端侧 CNN 部署的标准步骤——你训一个模型、做 QAT、导出 INT8 模型、部署到手机。流程清晰、工具成熟、效果可控。

3.2 Transformer 带来的三个根本性新挑战

当量化的对象从 CNN 变成 Transformer——尤其是大语言模型——时，至少有三件事发生了根本性变化。

第一：Activation Outlier 成了头号敌人。

在 LLM 中，某些 channel 的激活值可以比其他 channel 大 100 倍甚至 1000 倍。这不是异常值，也不是噪声——这是模型正常工作的方式。

这种 outlier 现象至少有三个已知来源：

一是 LayerNorm 的 channel-wise 缩放。LayerNorm 在归一化之后有一组可学习的 scale 和 bias 参数，训练过程中某些 channel 的 scale 可能被训到很大的值，导致该 channel 的输出激活远大于其他 channel。

二是 Attention Sink 现象。Transformer 的 attention 层在处理序列时，有时会把大量注意力集中到某些特定 token 上（通常是序列开头的 token 或分隔符）。这些 token 对应的激活值会异常大。Bondarenko et al.（2023）认为这实际上是 attention 层在实现一种"no-op"操作——当模型对某个位置"没什么要更新的"时，它需要把注意力权重推向极端值来让 softmax 输出接近零，这个过程会产生极大的中间激活值。

三是 Adam 优化器的累积效应。Adam 对每个参数维护独立的二阶矩估计（对角近似），这在某些 channel 上可能导致 scale 的持续累积，最终产生 outlier channel。

为什么这对量化是灾难性的？因为 per-tensor 量化的 scale 由最大值决定。如果某个 channel 的激活值是其他 channel 的 100 倍，那整个 tensor 的量化范围都要拉大到能覆盖这个 outlier，导致 99% 的正常值只能用很少的几个量化格点表示——信息被严重压缩。

SmoothQuant（2023）的核心观察就是：权重很容易量化，激活很难量化，因为问题出在激活的 outlier 上。它的解决方案是通过一个等价变换，把激活的量化难度"转移"一部分到权重上。

QuaRot（NeurIPS 2024）和 SpinQuant（2024）走得更远：它们用正交旋转矩阵（Hadamard 矩阵或可学习旋转）预处理激活和权重，使得 outlier 被"分散"到所有 channel 上，从而让量化更均匀。OSTQuant（ICLR 2025）进一步优化了全局旋转的策略，在 W4A4KV4 配置下将性能差距缩小了 32%。

这跟 QAT 的关系是：PTQ 阵营的这些方法（SmoothQuant、QuaRot、SpinQuant）是在"不改权重"的前提下尽量消除 outlier 的影响。QAT 则是让权重在训练中主动适应 outlier 的存在——更彻底但也更贵。一个重要的新趋势是把两者结合：RoSTE（2025）先用旋转消除 outlier，再在旋转后的基础上做 QAT，效果优于单独使用任何一种方法。

第二：KV Cache 量化成了新的性能瓶颈。

在 LLM 推理中，KV cache 存储了所有已处理 token 的 key 和 value 向量。序列越长、batch 越大，KV cache 占用的显存越多。对于 128K context 的模型，KV cache 的显存占用可能超过模型权重本身。

量化 KV cache（比如从 FP16 压缩到 INT4 或 FP8）能直接提升推理吞吐量和最大序列长度。但 KV cache 的分布特殊——它随 position、content 和 layer 变化极大，而且是在推理时动态产生的，不可能在训练前做 calibration。

LLM-QAT（Liu et al., ACL 2024 Findings）是最早明确把 KV cache 量化纳入 QAT 训练的工作。它在训练时对 KV cache 也插入 fake quant，让模型学会在 KV cache 被量化的情况下仍然保持注意力计算的精度。实验表明，4-bit 权重 + 4-bit KV cache + 8-bit 激活的配置比全 4-bit 配置效果好得多——说明 KV cache 量化需要单独关注，不能简单地跟权重用同一套策略。

第三：模型规模让训练成本爆炸。

CNN 时代的 QAT 是"训几个小时"的事。LLM 时代完全不同。

LLM-QAT 在 LLaMA-7B 上做全参数 QAT 训练耗时约 90 个 A100 GPU 小时。OmniQuant（ICLR 2024）作为 PTQ 方法只需要 1.6 小时，SmoothQuant 更是只要 10 分钟。成本差距是数量级的。

而且 QAT 需要的不只是算力——还需要训练数据。对于预训练阶段的 QAT，理想情况下应该使用跟原始预训练相同或相似分布的数据。但很多模型（特别是闭源模型被开源权重后）的训练数据是不可获取的。LLM-QAT 用模型自身的生成数据做蒸馏目标，部分绕开了这个限制，但生成数据的质量和分布跟真实训练数据仍有差距。

EfficientQAT 提出了一个实用的折中方案：先做 block-wise 全参数训练（Block-AP），逐块优化而不是端到端，大幅降低显存需求；然后做端到端量化参数训练（E2E-QP），只训 scale 和 zero-point。这套方案让单卡 A100-80GB 就能处理 7B 模型的 QAT——但对 70B 模型仍然不够。

3.3 VLM 和多模态的额外复杂性

视觉语言模型（VLM）的量化更加复杂，因为视觉编码器和语言解码器的激活分布差异很大。图像侧的激活通常更均匀、更适合量化，但语言侧的 outlier 问题更严重。

一个常见的做法是对不同模态使用不同的量化策略——视觉编码器用 W8A8、语言解码器用 W4A8。但这给 QAT 带来了额外的复杂性：你需要在同一个训练循环中管理多种不同的 fake quant 配置。

Gemma 3n 和 Gemma 4 的 Edge 系列模型（E2B/E4B）就是多模态端侧部署的典型案例：它们同时处理文本、图像、甚至音频输入，需要在极有限的端侧算力下运行。QAT 几乎是必选项——因为端侧推理引擎（如 LiteRT/ExecuTorch）要求全静态量化，而 PTQ 在多模态模型上的激活量化通常不够稳定。

四、技术路线图：QAT 和其他方法到底怎么分工

量化不只有 QAT 和 PTQ 两条路。过去两年涌现了大量方法，每种都有自己的定位。要搞清楚 QAT 的价值，必须理解它在整个量化技术版图中的位置。

4.1 PTQ 家族的演进

PTQ 方法可以按"量化什么"和"核心机制"来分类：

Weight-only 量化——只量化权重、激活保持 FP16。这是最简单也最安全的做法。

• RTN（Round-to-Nearest）是 baseline：直接把权重 round 到最近的格点。在 W8 下几乎无损，在 W4 下通常有明显掉点。
• GPTQ（2022）用逆 Hessian 信息逐层重构权重，让量化误差被最小化。在 W4 下效果明显优于 RTN，但在 W3 以下开始退化。
• AWQ（2023）观察到不同 channel 对精度的重要性不同——激活幅度大的 channel 对应的权重更重要。它通过 per-channel scaling 保护重要权重，实现了比 GPTQ 更稳定的 W4 量化。

Weight + Activation 量化——权重和激活都量化。这是获得真正的推理加速和显存节约所必需的（因为矩阵乘法的两个操作数都得是低精度才能用 INT 硬件）。

• SmoothQuant（2023）通过数学等价变换，把激活的量化难度转移一部分到权重上。核心观察：权重分布规整容易量化、激活有 outlier 难以量化，那就通过 per-channel scaling 把激活"抹平"、权重"变难一点"，整体量化误差反而更小。
• QuaRot / SpinQuant / OSTQuant（2024-2025）用旋转矩阵（通常是 Hadamard 矩阵）变换权重和激活，使分布更均匀、outlier 被分散。在 W4A4KV4 配置下表现优异，且不需要重新训练。

介于 PTQ 和 QAT 之间的方法：

• OmniQuant（ICLR 2024）冻结权重、只训量化参数（Learnable Weight Clipping + Learnable Equivalent Transformation）。它只需要 calibration 数据量级的数据、1.6 小时的训练时间，但效果接近 QAT。严格来说它还是 PTQ（因为模型权重不变），但引入了可学习参数的优化。

4.2 QLoRA 不是 QAT——这个区分很重要

QLoRA（Dettmers et al., 2023）是把预训好的模型权重量化到 NF4（4-bit NormalFloat），冻结量化权重，然后在上面训 LoRA adapter。

很多文章把 QLoRA 归为 QAT 体系。这是不准确的。

关键区别：在 QLoRA 中，量化是在训练开始前一次性完成的，量化参数在整个训练过程中不变。 模型并没有"感知"到量化并做出适应——它只是在一个固定的低精度底座上训练了一组额外参数。QLoRA 的目标是"降低微调的内存成本"，不是"让模型学会在低精度下更好地工作"。

QA-LoRA（Xu et al., 2023）才是真正的量化感知 LoRA：它在 LoRA 微调过程中引入 fake quantization，让量化参数参与优化。训练完成后，LoRA adapter 被合并回主模型、整体量化导出。

这个区分对工程选型有实际影响：

• 如果你的目标是"低内存做微调、部署时不需要特别低的精度" → QLoRA 就够了
• 如果你的目标是"产出一个在目标硬件上以 INT4 运行的模型、且精度有严格要求" → 需要 QA-LoRA 或其他形式的 QAT

4.3 蒸馏与 QAT 的组合：低比特下的标配

在 4-bit 尤其是 sub-4-bit 的 QAT 中，纯交叉熵 loss 训练往往不够。原因直观：量化噪声太大，模型容易在噪声中迷失方向、收敛到一个差的局部最优。

知识蒸馏提供了一个额外的信号：用原始全精度模型的输出分布（soft label）作为目标，引导量化模型的学习方向。这相当于给优化器一个"参考答案"——不只是告诉模型"正确标签是什么"，还告诉它"正确的置信度分布长什么样"。

• LLM-QAT（ACL 2024 Findings）的做法最有代表性：它用模型自己的生成数据做蒸馏（data-free distillation）。先让全精度模型生成一批文本，然后以全精度模型在这些文本上的 logit 分布为目标来训练量化模型。这个做法绕开了对原始训练数据的依赖。
• BitDistiller（2024）把 self-distillation 和 QAT 结合，在 sub-4-bit 下取得了明显的效果提升。
• NVIDIA 的 QAD（Quantization-Aware Distillation）把蒸馏从 QAT 中独立出来，作为 PTQ 之后的一个单独的精度恢复阶段。它的定位很明确：PTQ 先压、QAD 再补，两步走。

工程上的实践建议：如果你在做 4-bit 或更低比特的 QAT，蒸馏 loss 不是可选项，而是几乎必须的。 没有蒸馏的低比特 QAT，效果通常跟好的 PTQ 差不多——那还不如直接用 PTQ。

4.4 QAT 与原生低比特训练的边界正在模糊

这是一个值得关注的趋势。

传统 QAT 的范式是"先全精度预训练 → 再切换到低比特微调"。模型先在一个"干净"的世界里学到知识，再在有量化噪声的世界里做适应。

但以下工作正在打破这个范式：

BitNet b1.58（Microsoft, JMLR 2026）：从第一步开始就用 ternary weight（{-1, 0, +1}）训练，从来没有全精度阶段。它用 STE 做梯度回传，但整个训练 recipe——LR schedule、weight decay 策略、架构设计（用 BitLinear 替换 nn.Linear）——都是为 1.58-bit 从头设计的。在 2B 参数、4T token 的规模上，性能接近全精度模型。

NVFP4 Pretraining（NVIDIA, 2025/2026）：在整个预训练过程中使用 FP4 做前向和反向传播的矩阵乘法。核心技术包括 Random Hadamard Transform 抑制 outlier、2D block scaling、stochastic rounding 消除梯度偏差、以及在训练最后阶段切换部分层到高精度。12B 模型在 10T token 上训练，loss 和下游任务精度跟 FP8 baseline 几乎一致。

Continual Quantization-Aware Pre-Training（ACL 2025 Findings）：研究如何从 16-bit 预训练平滑过渡到 1.58-bit 训练。实验表明，先做几千步 16-bit 训练再切换到 1.58-bit（而不是从头就用 1.58-bit），最终效果更好。

这些工作跟传统 QAT 的区别在哪？

传统 QAT 假设你有一个已经训好的全精度模型，QAT 是一个"事后"步骤。BitNet 和 NVFP4 training 根本没有全精度模型——训练本身就在低比特下完成。它们共享 QAT 的核心原理（fake quant + STE），但在定位上是"低比特训练方法"而不是"量化压缩方法"。

这对 QAT 的未来意味着什么？ 如果原生低比特训练在未来 2-3 年成熟到可以大规模使用，那 QAT 的定位会进一步收窄——从"预训练后的压缩微调"变成"已有模型的精度修补"。但在可见的未来，大多数团队拿到的模型仍然是全精度或 FP8 预训练的，QAT 作为"事后压缩"的工具仍有明确的使用场景。

五、工程真相：QAT 为什么"听起来合理、做起来痛苦"

5.1 一个端侧部署场景的决策链路

假设你的团队要把一个 7B 参数的语言模型部署到手机上。目标硬件是搭载 Snapdragon 8 Gen 3 的旗舰 Android 手机，推理引擎用的是 XNNPACK（通过 ExecuTorch）。内存预算是模型加载 + KV cache 总共不超过 4GB，推理延迟要求 decode 速度 > 15 token/s。

第一步：评估 Weight-only PTQ。

用 GPTQ/AWQ 做 W4A16 量化，模型权重从 14GB 压到 ~3.5GB。精度在 PPL 和下游任务上几乎无损。

但问题来了：XNNPACK 的矩阵乘法 kernel 要求两边操作数都是整数（INT8×INT4 或 INT8×INT8）。W4A16 意味着每次计算都要把 FP16 激活动态量化到 INT8——XNNPACK 支持这个，但你需要用 静态量化 的激活（即 scale 在编译时确定，不是推理时动态计算），才能获得最佳性能。动态量化的开销在端侧上可能吃掉 20-30% 的推理速度。

第二步：尝试 W4A8 PTQ。

用 SmoothQuant 预处理 + 静态 W4A8 量化。激活的 scale 通过 calibration 数据确定。

这里踩了第一个坑：calibration 数据用的是 WikiText，但实际使用场景是中文对话。分布不匹配导致激活的 scale 估计不准，某些层的激活 outlier 在实际推理时超出了 calibration 阶段确定的范围，被截断后精度下降 15%。这在端侧上是不可接受的。

换用领域数据做 calibration 能改善一部分，但 outlier 的问题没有根本解决——因为 PTQ 的 scale 是固定的，它没法预见推理时会出现什么样的输入。

第三步：被迫考虑 QAT。

现在需要做的事情是：让模型在训练阶段就适应 W4A8 静态量化的约束，特别是让模型学会在激活被量化的情况下仍然保持输出质量。

这个决策一旦做出，后面要面对的就不是"跑几个脚本"的问题了：

• 训练 pipeline：需要 torchtune + torchao 的 QAT recipe，或者自己用 PyTorch FX 插入 fake quant 节点。需要搞清楚 XNNPACK 后端到底在哪些算子上做量化、对应的 fake quant 应该插在模型的哪些位置。
• 训练数据：需要跟目标任务分布一致的数据。数据量太少（如 128 条）会过拟合，太多（如百万条）会导致训练成本接近全量微调。EfficientQAT 的经验是 block-wise 阶段用 128 条、E2E-QP 阶段可以换更大数据集。
• 超参数：QAT 的学习率通常需要比标准微调低 5-10 倍。EfficientQAT 建议 2-bit 用 2e-5、4-bit 用 1e-5。还需要决定 QAT 的训练步数——太少不起作用、太多可能过拟合到训练数据的量化特性上。
• 导出与部署：QAT 训完的 PyTorch checkpoint 需要经过 torch.export → ExecuTorch delegate → XNNPACK backend 的转换链路。任何一步的格式不兼容或算子不支持都可能导致量化信息丢失、需要手动修复。

最终结果：QAT 训练本身可能只需要 2-3 天。但上下游的工具链对齐、调参、导出调试、端上验证、回归测试，加在一起可能需要 3-4 周。

这就是为什么 QAT"听起来合理但做起来痛苦"的核心——训练本身不是瓶颈，工程集成才是。

5.2 真实踩坑清单

以下是 QAT 工程实践中最常见的问题。每个坑都标注了为什么会踩、表面症状、深层原因和缓解方法。

坑 1：Fake quant 覆盖范围不完整

表面症状：QAT 训练后的模型 PPL 很好，但部署到目标硬件后精度大幅下降。

为什么会踩：只在 Linear 层插入了 fake quant，没有覆盖 Embedding 层的输出、LayerNorm 的输出、或者残差连接的中间结果。

深层原因：端侧推理引擎会量化所有算子的输入/输出，而你在训练时只模拟了一部分。那些没被模拟的位置，模型从未"见过"量化噪声，部署时就会措手不及。

缓解：部署先行——先搞清楚目标推理引擎的量化算子覆盖范围（哪些算子的输入/输出会被量化到什么精度），然后倒推 fake quant 的插入位置。PyTorch 官方的 QAT blog 也强调了这一点：QAT 的 fake quant 配置必须跟目标部署后端匹配。

坑 2：学习率没有为 QAT 调整

表面症状：QAT 阶段 loss 不降反升，或者剧烈震荡。

深层原因：QAT 在前向传播中引入了额外的量化噪声，相当于给 loss landscape 加了很多小扰动。如果学习率太大，优化器会被这些扰动"带跑"，在局部最优之间来回跳。

缓解：QAT 阶段的学习率通常应该设为标准微调学习率的 1/5 到 1/10。NVIDIA 的 TensorRT Model Optimizer 建议 QAT 训练时长约为原始训练的 10%，LR 相应降低。Google Gemma 的 QAT 更激进——只做约 5000 步，用蒸馏 loss 而不是纯 CE loss。

坑 3：Calibration 数据与训练/推理数据分布不匹配

表面症状：QAT 训练收敛了，但在实际输入上精度比 PTQ 还差。

深层原因：QAT 训练初期的 scale/zero-point 通常由 calibration 数据初始化。如果 calibration 数据的分布跟后续训练数据或实际推理数据差距太大，初始的量化参数就是偏的，训练要花很多步才能纠正——甚至可能纠正不过来。

缓解：calibration 数据应该跟 QAT 训练数据同分布。EfficientQAT 推荐 calibration 数据量至少 128 条，从 WikiText 和 C4 各取一半以增加分布多样性。

坑 4：Per-tensor activation quantization 遇到 outlier channel

表面症状：整体 PPL 正常，但某些特定输入的输出质量急剧下降。

深层原因：per-tensor 量化的 scale 由整个 tensor 的最大值决定。一个 outlier channel 就能把 scale 撑大、让其他所有 channel 的有效精度降低。

缓解：使用 per-token 或 per-channel activation quantization。如果硬件不支持 per-channel，先用 SmoothQuant 或旋转变换消除 outlier，再做 QAT。

坑 5：KV cache 量化被遗漏

表面症状：短序列推理正常，长序列（>2K token）推理时显存爆炸或速度急剧下降。

深层原因：权重和激活都做了 QAT，但 KV cache 还是 FP16。长序列时 KV cache 可能占总显存的 50% 以上。

缓解：在 QAT 训练中对 KV cache 也插入 fake quant。注意 KV cache 的量化粒度通常是 per-head 或 per-token 而不是 per-tensor，需要特殊处理。LLM-QAT 是最早做这个的工作，效果显著。

坑 6：训练时 dynamic quantization、部署时 static quantization

表面症状：QAT 训练指标很好，但导出到端侧后精度明显下降。

深层原因：训练时 fake quant 的 scale 是逐 batch 动态计算的（基于当前 batch 的 min/max），部署时是用 calibration 数据算出一个固定的 scale。两者不一致。

缓解：如果目标是静态量化部署，QAT 训练也应该使用静态 scale（在一定步数后冻结 observer）。PyTorch 的 QAT 流程支持 convert 步骤中切换 observer 类型。

坑 7：Sub-4-bit QAT 的 gradient 不稳定

表面症状：训练 loss 出现 NaN、inf，或者在某个步数后突然发散。

深层原因：在 2-bit 或 3-bit QAT 中，STE 的梯度近似误差变得很大，可能导致某些层的梯度异常放大。BitNet 的研究发现，在 1-bit 训练中 weight decay 的行为跟全精度完全不同——latent weight 的幅度可以被解读为"对当前 bit 值的置信度"，太强的 weight decay 会让 bit 值频繁翻转。

缓解：gradient clipping（通常设 1.0）；progressive quantization（先用 8-bit QAT 训一阵，再逐步降到 4-bit、2-bit）；使用 Bit-by-Bit 框架中的 progressive bit reduction 策略。

坑 8：导出格式不兼容

表面症状：QAT 训完的 checkpoint 无法被目标推理引擎正确加载，或者加载后量化信息丢失。

深层原因：不同框架对量化模型的表示方式不同。PyTorch 的 FX graph 量化模型跟 ONNX 的量化 op 不一定一一对应；TensorRT 的量化格式又跟两者都不同。某些 fake quant 配置（如 per-group quantization）在导出时可能没有对应的标准 op。

缓解：先确认目标格式再开始训练。 EfficientQAT 支持导出为 GPTQ v2 格式和 BitBLAS 格式——这意味着训完可以直接用 GPTQModel 加载。如果你的目标是 TensorRT-LLM，建议直接用 NVIDIA Model Optimizer 的 QAT API，它保证了跟 TensorRT-LLM 的格式兼容。

坑 9：评测指标选择偏差

表面症状：QAT 后 WikiText PPL 改善明显，但实际任务（如推理、代码生成、数学）精度反而下降。

深层原因：PPL 衡量的是"平均每个 token 的预测不确定性"，它对所有 token 等权重。但不同任务对不同 token 的敏感度差异很大——推理任务中关键推理步骤的 token 如果出错，整个答案就错了，但这在 PPL 中可能只体现为微小的变化。

缓解：用多样化的 benchmark 评测（至少包括 HellaSwag、ARC、MMLU 等任务级评测），不要只看 PPL。IJCAI 2025 的大规模量化评测研究也发现，不同量化方法在不同任务类型上的表现差异很大。

坑 10：训练数据量的两难

表面症状：数据太少 → QAT 过拟合，在 calibration 数据上精度好但在新数据上差。数据太多 → 训练成本接近全量微调，失去了 QAT"轻量"的优势。

深层原因：QAT 需要足够的数据多样性来让量化参数泛化，但又不需要像预训练那样遍历全部语料。这个"刚好"的数据量跟模型大小、量化比特数、任务类型都有关，没有通用的经验值。

缓解：EfficientQAT 的经验值是 block-wise 阶段 128 条足够（因为逐块优化，每块的参数量小），E2E-QP 阶段可以增加到几千条。Google Gemma 3 QAT 用了约 5000 步训练。作为起点，可以先用几百条试跑，再根据 loss 曲线和验证集表现决定是否增加数据。

坑 11：Mixed-precision 配置遗漏敏感层

表面症状：所有层都压到 4-bit 后精度崩塌，但只保留几层 FP16 就能恢复大部分精度。

深层原因：LayerNorm、Softmax、残差连接的加法、以及 Embedding 层对量化特别敏感。这些层的参数量很小，保持 FP16 几乎不影响模型大小和推理速度，但量化它们会造成不成比例的精度损失。NVIDIA 的 NVFP4 训练论文也发现，最后四个 Transformer block 保持 BF16 对训练稳定性至关重要。

缓解：默认对 LayerNorm、Softmax、Embedding、残差 add 保持高精度。只对 Linear 层做低比特量化。

坑 12：MoE 模型的 expert 不均匀量化

表面症状：模型整体精度下降不大，但某些特定类型的输入（对应于活跃度低的 expert）表现急剧恶化。

深层原因：MoE 模型中不同 expert 的训练数据量天然不均匀。活跃度高的 expert 在 QAT 中"见过"更多数据、量化参数优化得更充分；活跃度低的 expert 可能训练不足，量化后掉点严重。

缓解：这是一个目前几乎没有被系统研究的问题。QAT scaling law 论文也明确指出 MoE 架构下的 QAT 是一个未解难题——MoE 有更多的 weight 参数但激活参数不变，weight 和 activation 的量化误差比例可能跟 dense 模型完全不同。

5.3 方法选型框架

根据以上分析，给出一个工程决策树——帮你判断当前问题应该先走哪条路。

第一个问题：目标量化精度是多少？

• W8A8 或 FP8：PTQ 几乎总是够用。SmoothQuant 或者 NVIDIA 的 FP8 PTQ 即可。精度损失通常在 1% 以内。不需要 QAT。
• W4A16（weight-only 4-bit） ：AWQ / GPTQ 是成熟方案，精度损失通常在 2% 以内。模型 > 7B 时损失更小。不需要 QAT。
• W4A8（weight 4-bit + activation 8-bit） ：灰色地带。先试 SmoothQuant / QuaRot + PTQ，如果精度够了就不需要 QAT。如果精度差距 > 3%，考虑 QAT。
• W4A4 或更低：QAT 几乎必要，但也最难做。配合蒸馏、rotation、mixed-precision。

第二个问题：部署目标是什么？

• 服务端 GPU（H100/A100 等） ：可以用 dynamic quantization、可以混合精度、可以保留部分 FP16 层。PTQ 的灵活度很高，QAT 的必要性低。
• 端侧/移动端（XNNPACK / ExecuTorch / Core ML / Qualcomm） ：通常要求全静态量化、全整数算术。激活也必须量化且 scale 在编译时确定。这是 QAT 价值最大的场景。
• NVIDIA Blackwell + NVFP4：PTQ + QAD 可能是最优路径（NVIDIA 自己的推荐流程）。

第三个问题：模型多大？

• > 70B：QAT 的训练成本极高（至少需要多张 80GB GPU），且大模型对 PTQ 的鲁棒性通常更好。除非有极其严格的精度要求，否则不建议 QAT。
• 7B - 70B：视精度需求决定。EfficientQAT 可以在单卡/少量卡上处理 7B-13B。
• < 7B：PTQ 掉点通常比大模型严重。QAT 的价值-成本比最高。Google Gemma 3 QAT 主要面向 1B-27B 这个区间。Unsloth 的 QAT 实验也发现，270M 模型在 PTQ int4 下性能严重退化，QAT 可以显著改善。

第四个问题：有训练 pipeline 和数据吗？

• 没有：只能用 PTQ。这是 QAT 最硬的门槛——它需要你能做训练/微调，需要有合适的数据。
• 有：QAT 在技术上可行，评估 ROI。

六、当前前沿与未解问题

6.1 QAT 的 Scaling Law：一些反直觉的发现

2025 年出现了两项关于 QAT scaling behavior 的重要研究，揭示了一些跟直觉不符的规律。

Scaling Law for QAT（Chen et al., 2025，OpenGVLab，268 个 QAT 实验）发现：

• 量化误差随模型规模增大而降低——大模型更容易量化，这跟直觉一致
• 量化误差随训练 token 增多而升高——训练越多，量化越难！这反直觉
• 量化误差随量化粒度变粗而增大——per-group-256 比 per-group-32 差很多

第二个发现特别重要。它意味着：一个在 10T token 上训练的模型，比一个在 1T token 上训练的同结构模型更难量化。 原因是训练越充分，模型的权重对精度的利用越"极致"——微妙的权重差异对最终输出的影响更大——量化造成的信息丢失也就更严重。

这对工程实践的指导意义是：不要以为"模型训得越好、量化越容易"。恰恰相反，越强的模型在低比特量化时可能掉点越多——因为它的信息密度更高。

这个发现也呼应了另一个独立的观察：PTQ 的误差也随预训练数据量增大而增大。这说明量化难度不只取决于模型结构，还取决于模型被训得有多"满"。

Compute-Optimal QAT（Dremov et al., Apple/EPFL, 2025/2026, 757 个 QAT 实验）发现：

• 之前的共识是"QAT 占总训练的 10% 就够了"，但这个结论只在小训练预算下成立
• 随着总训练预算增加，最优 QAT 比例应该增加——当训练预算充裕时，分配给 QAT 的比例应该显著高于 10%
• 最优 QAT 比例可以用一个简单的统计量 "tokens-per-parameter-byte" 来预测
• 对于固定的显存预算，存在一个最优的 QAT 比特数选择——不一定是越高越好
• 提出了 cooldown + QAT fusion 技巧：把 LR decay 阶段和 QAT 阶段合并，省去重复的全精度训练

这两项研究合在一起传递的信息是：QAT 不是一个"加上去就完事"的步骤，它的最优配置跟模型规模、训练预算、目标比特数、数据量都有复杂的交互关系。 "最后 10% 做 QAT"这个 rule of thumb 在很多情况下不是最优的。

6.2 Rotation-Based 方法：QAT 的竞争者还是合作者？

2024-2025 年，rotation-based 量化方法（QuaRot、SpinQuant、KurTail、OSTQuant、SingleQuant）迅速发展，在 W4A4KV4 配置下取得了令人瞩目的效果——且不需要任何训练。

这引出一个自然的问题：如果 rotation + PTQ 已经这么好了，还需要 QAT 吗？

从目前的证据来看，答案是：rotation 是 QAT 的互补者而非替代者，但 rotation 确实把 QAT 的"必要门槛"推高了。

RoSTE（2025）的实验提供了直接对比：在 W4A4KV4 配置下，rotation + QAT-SFT 的组合优于纯 rotation PTQ（QuaRot/SpinQuant），也优于不用 rotation 的 QAT。两者是 1+1 > 2 的关系。

但"rotation + PTQ"已经非常强了——在很多模型和任务上，它的精度已经接近"rotation + QAT"。额外做 QAT 带来的边际收益可能只有 1-2%，而成本增加很多。

判断标准很清晰：如果 rotation + PTQ 的精度已经满足你的需求，就没必要做 QAT。 如果差那么一两个百分点正好是你的 SLA 边界，那 QAT 值得投入。

6.3 NVFP4 与 QAD：工业界的最新实践

NVIDIA 在 2025-2026 年推进了两条平行的低比特路线：

NVFP4 Pretraining：用 FP4 格式做整个预训练过程的矩阵乘法。NVFP4 比 MXFP4 的关键改进是：更小的 block size（16 vs 32）、FP8 scale factor（而不是只能表示 2 的幂的 E8M0）、以及额外的 FP32 master scale 提供更大的动态范围。

训练中的关键技巧包括：stochastic rounding（对梯度必须用，对权重和激活反而有害）、Random Hadamard Transform（抑制 block 级 outlier）、最后阶段的若干 Transformer block 保持 BF16。12B 模型在 10T token 上训练的结果表明 NVFP4 训练的 loss 和精度跟 FP8 baseline 几乎一致。

NVFP4 QAD：对于已有的全精度模型，用 PTQ 量化到 NVFP4 后，通过 QAT + 蒸馏（Quantization-Aware Distillation）恢复精度。这对小模型尤其重要——大模型（如 DeepSeek-R1 级别）PTQ 到 NVFP4 精度损失很小，但小模型的损失可能不可忽略。

NVIDIA 报告中有一个值得注意的细节：QARL（Quantization-Aware Reinforcement Learning）几乎是空白。 现代 LLM 的训练流程通常包括 SFT 和 RL（如 RLHF/GRPO）两个阶段。在 SFT 阶段做 QAT 是直接的（loss function 不变），但在 RL 阶段做 QAT——即在 actor 的前向传播和 rollout 生成中都使用量化——目前几乎没有被系统研究。这意味着如果你在 SFT 阶段做了 QAT，RL 阶段可能会"忘记"量化适应。

6.4 未解问题清单

以下是当前 QAT 领域最重要的未解问题：

MoE 架构下的 QAT。 目前几乎所有 QAT 研究都聚焦于 dense 模型。MoE 模型有大量参数但推理时只激活一小部分，权重和激活的量化误差比例可能跟 dense 模型完全不同。Gemma 4 的 26B A4B MoE 模型有 128 个小 expert，每个 token 只激活 8 个——这种架构下的 QAT 该怎么做？每个 expert 独立 QAT 还是全局 QAT？活跃度低的 expert 怎么处理？目前没有系统性的研究。

RL 阶段的量化感知训练。 如上所述，QARL 是一个重要但几乎空白的方向。如果我们希望量化模型在 RLHF/GRPO 训练后仍然保持量化友好性，就需要在 RL 阶段也引入 fake quant——但 RL 的训练动态跟 SFT 差异很大（reward signal 的方差高、策略更新不稳定），fake quant 的额外噪声可能让训练更加不稳定。

Quantization-Friendly Architecture Design。 与其在训练后费力做 QAT，不如一开始就设计出更适合量化的架构。BitNet 是这个方向最激进的尝试（用 BitLinear 替代 nn.Linear）。更温和的方案包括：使用 RMSNorm 替代 LayerNorm（减少 outlier）、使用 GQA/MQA 减少 KV cache 大小、使用 GLU 变体替代标准 FFN（更平滑的激活分布）。但目前还没有一套系统的"quantization-friendly design principles"——大部分架构决策是基于全精度性能做的。

自动化量化策略搜索。 NVIDIA 的 AutoQuantize 已经能自动搜索 per-layer 的最优量化格式（INT8 vs NVFP4 等）。但这目前只在 PTQ 层面。QAT 的超参数空间更大（每层的比特数、scale 的粒度、QAT 的步数和 LR、哪些层做 QAT 哪些不做），自动搜索的成本也更高。

Compiler / Hardware / Kernel co-design。 量化不只是算法问题——同样是 W4A4 量化，不同硬件上的实际加速比可能差异很大，取决于是否有对应的高效 kernel。QAT 训出的模型如果在目标硬件上没有对应的 INT4 GEMM kernel，那量化就只能省显存、不能省计算。TensorRT-LLM、vLLM、ExecuTorch 对不同量化格式的支持程度不同，这在工程上是一个不断变化的约束。

七、结论：谁该做，谁别碰

7.1 QAT 在未来 2-3 年最可能落在哪里

端侧和边缘部署的标配生产步骤。 这是 QAT 价值最确定的场景。Gemma 3/4 的 QAT checkpoint、Apple 的 compute-optimal QAT 研究、PyTorch/ExecuTorch 的 QAT pipeline——都指向同一个方向：如果你要把模型部署到手机、平板、车端或 IoT 设备，QAT 大概率是你生产流程的一部分。端侧推理引擎对静态量化和全整数算术的要求，让 PTQ 的天花板变低，QAT 的必要性变高。

服务端大模型的 FP4/INT4 精度恢复。 随着 NVIDIA Blackwell GPU 和 NVFP4 格式的普及，PTQ 到 FP4 在大模型上可能够用（因为大模型对量化更鲁棒），但在中小模型上可能需要 QAD 来补精度。这里的 QAT 更像是一个"polish"步骤——不需要做很多步，但这几步的价值很大。

小模型的极限压缩。 1B-7B 级别的模型在 sub-4-bit PTQ 下通常掉点严重。QAT 是把这些小模型压到 2-bit / 3-bit 还能用的几乎唯一路径。BitDistiller、EfficientQAT 在这个区间展示了明确的优势。

7.2 哪些团队值得投入 QAT

• 有明确端侧部署硬约束的团队：需要全静态量化、W4A8 或更低、目标是 XNNPACK/Core ML/Qualcomm DSP 等。这类团队做 QAT 不是"可选优化"而是"必经之路"。
• 在特定任务上有严格精度 SLA 的团队：比如 PTQ 后精度差 2%，但业务要求 <1% 的退化。QAT 就是弥补这 1% 的工具。
• 做小模型（< 7B）且需要极限压缩的团队：小模型的参数冗余度低，PTQ 的损伤更大，QAT 的边际收益更高。
• 有完整训练 pipeline 的团队：QAT 需要你能做训练——有 GPU、有数据、有代码。如果这些你已经有了，QAT 的增量成本主要是工具链对齐和调参，而不是基础设施建设。

7.3 哪些团队不该碰 QAT

• 只需要 W4A16 weight-only quantization 的团队：AWQ/GPTQ 已经足够成熟、足够好。在 weight-only 场景下做 QAT 的 ROI 很低。
• 没有训练 pipeline 的团队：如果你拿到的是一个开源模型的 checkpoint，没有训练代码和数据，那你能做的只有 PTQ。
• 目标精度是 W8A8 或 FP8 的团队：这个精度级别的 PTQ 几乎无损，QAT 没有附加值。
• 模型 > 70B 且没有大规模训练资源的团队：70B 模型的 QAT 需要大量 GPU 和长时间训练，且大模型对 PTQ 的鲁棒性通常足够好。成本和收益不对称。
• 追求速度而非精度极限的团队：如果"差不多够好"就行，PTQ 的迭代速度比 QAT 快一个量级。先用 PTQ 上线、后续再考虑 QAT 优化，是更务实的策略。

7.4 这个方向最容易被误解的是什么

误解一：QAT 是万能的精度恢复工具。 不是。在 W4A4 sub-4-bit 下，即使做了 QAT 也可能无法恢复到可接受的精度——EfficientQAT 在 W4A4 配置下 perplexity 飙升到 76 就是例子。QAT 有自己的能力边界。

误解二：QAT 一定很贵。 不一定。Google Gemma 3 QAT 只做了约 5000 步。EfficientQAT 的 block-wise 方案在单张 A100 上就能处理 7B 模型。"QAT = 重新训一遍"是对传统 full QAT 的印象，现代 QAT 方法已经把成本压到了 PTQ 的几倍到十几倍，而不是预训练的量级。

误解三：QAT 是过时技术，已经被更先进的 PTQ 替代。 没有。PTQ 确实在中高比特场景替代了 QAT 的需求，但在低比特、激活量化、端侧部署等场景，QAT 仍然不可替代。更准确地说：QAT 的价值区间变窄了，但在那个区间内它的价值更高了。

误解四：BitNet / NVFP4 training 就是 QAT。 严格来说不是。它们是原生低比特训练——从头就在低精度下训，不存在"先全精度再切换"的步骤。它们共享 QAT 的部分技术（fake quant、STE），但定位完全不同。QAT 是"压缩已有模型"，原生低比特训练是"用更少的算力训新模型"。两者解决不同的问题。

误解五："多训几轮就能解决低比特 QAT 的问题"。 QAT scaling law 的研究明确表明：在 sub-4-bit 下，更多的训练 token 可能导致量化误差增加而不是减少。问题不在训练量，而在于量化格子本身的表达能力有限、STE 的梯度近似在低比特下严重失真、以及 activation outlier 的结构性挑战。这些不是"多训几轮"能解决的，需要算法层面的突破。

最后说一句关于 QAT 在整个量化版图中的定位。

量化技术在过去两年的演进方向，是从"一种压缩手段"变成了"一种贯穿训练-部署全链路的设计约束"。PTQ 是事后压缩，QAT 是训练时感知压缩，BitNet/NVFP4 是直接在低精度下训练。这三者不是竞争关系，而是一个连续光谱上的不同点——你选哪个点，取决于你愿意为量化付出多少训练成本、你的精度底线在哪里、以及你的部署目标是什么。

QAT 就在这个光谱的中段。它既不像 PTQ 那样零成本（但也因此不是默认选择），也不像原生低比特训练那样需要改变整个训练范式（但也因此更容易被现有团队采用）。这就是它在今天的位置：一个精确的工具，用在精确的场景里。

参考资料

论文

1. Jacob et al. "Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference." CVPR 2018. — QAT 的奠基性工作
2. Bengio et al. "Estimating or Propagating Gradients Through Stochastic Neurons for Conditional Computation." 2013. — STE 的理论基础
3. Esser et al. "Learned Step Size Quantization (LSQ)." ICLR 2020. — 可学习 scale 的经典方法
4. Xiao et al. "SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models." ICML 2023.
5. Frantar et al. "GPTQ: Accurate Post-Training Quantization for Generative Pre-Trained Transformers." ICLR 2023.
6. Lin et al. "AWQ: Activation-Aware Weight Quantization for LLM Compression and Acceleration." MLSys 2024.
7. Liu et al. "LLM-QAT: Data-Free Quantization Aware Training for Large Language Models." ACL 2024 Findings.
8. Chen et al. "EfficientQAT: Efficient Quantization-Aware Training for Large Language Models." ACL 2025.
9. Chen et al. "Scaling Law for Quantization-Aware Training." arXiv 2505.14302, 2025.
10. Dremov et al. "Compute-Optimal Quantization-Aware Training." arXiv 2509.22935, Apple, 2025/2026.
11. Ashkboos et al. "QuaRot: Outlier-Free 4-Bit Inference in Rotated LLMs." NeurIPS 2024.
12. Liu et al. "SpinQuant: LLM Quantization with Learned Rotations." 2024.
13. Hu et al. "OSTQuant: Refining LLM Quantization with Orthogonal and Scaling Transformations." ICLR 2025.
14. Wang et al. "BitNet: Scaling 1-Bit Transformers for Large Language Models." JMLR 2026.
15. Ma et al. "BitNet b1.58 2B4T Technical Report." 2025.
16. Nielsen & Schneider-Kamp. "Continual Quantization-Aware Pre-Training." ACL 2025 Findings.
17. Mishra et al. "Pretraining Large Language Models with NVFP4." NVIDIA, 2025/2026.
18. Shao et al. "OmniQuant: Omnidirectionally Calibrated Quantization for Large Language Models." ICLR 2024.
19. SingleQuant. "Efficient Quantization of Large Language Models in a Single Pass." arXiv 2511.22316, 2025.
20. RoSTE. "An Efficient Quantization-Aware Supervised Fine-Tuning Framework." arXiv 2502.09003, 2025.
21. Czakó et al. "Addressing Activation Outliers in LLMs: A Systematic Review." IEEE Access, 2025.
22. Bit-by-Bit. "Progressive QAT with Outlier Channel Handling." OpenReview, 2025/2026.
23. NVIDIA. "Quantization-Aware Distillation for NVFP4 Inference Accuracy Recovery." Technical Report, 2026.

官方文档与博客

24. PyTorch Blog. "Quantization-Aware Training for Large Language Models with PyTorch." 2024.7.
25. NVIDIA Developer Blog. "How Quantization Aware Training Enables Low-Precision Accuracy Recovery." 2025.11.
26. Google Developers Blog. "Gemma 3 QAT Models: Bringing State-of-the-Art AI to Consumer GPUs." 2025.4.
27. Google AI for Developers. "Gemma 3 Model Overview." — QAT checkpoint 的官方说明
28. Google Developers Blog. "Gemma 3 on Mobile and Web with Google AI Edge." 2025.3. — 端侧部署实践
29. NVIDIA. "Optimizing LLMs for Performance and Accuracy with Post-Training Quantization." 2025.8. — AutoQuantize 与 NVFP4 PTQ

工程实践

30. Unsloth / Kaitchup. "QAT vs PTQ for Small Models." 2025.11. — Gemma 3 270M 上的 QAT vs PTQ 对比实验
31. OpenGVLab/EfficientQAT GitHub Repo. — 完整的 QAT 训练脚本与配置
32. pprp/Awesome-LLM-Quantization GitHub Repo. — LLM 量化方法的全面索引