一、Mixed Precision Training [2017] [粗读]

论文：《Mixed Precision Training》

论文是关于混合精度训练的，考虑到混合精度训练的思想已经广为人知，因此这里仅做粗读。

1. Introduction：略（参考原始论文）。

2. 相关工作：略（参考原始论文）。

1.1 方法

1. 我们介绍了 training with FP16 的关键技术，同时仍然匹配 FP32 training session 的 model accuracy：single-precision master weights and updates、loss-scaling 、accumulating FP16 products into FP32 。

   单精度浮点数为 float32、双精度浮点数为 float64 。

1.1.1 FP32 Master Copy Of Weights

1. 在混合精度训练中，权重、activations 以及梯度以 FP16 格式存储。为了匹配 FP32 网络的准确率，我们维护权重的一份 FP32 master copy ，并在 optimizer step 中用 weight gradient 来更新它。在每次迭代中，使用 master weights 的 FP16 copy 进行正向传播和反向传播，将 FP32 training 所需的存储和带宽减半。Figure 1 说明了这种混合精度训练过程。

   

2. 虽然 FP32 master weights 的需求并非普遍存在，但有两个可能的原因解释为什么许多网络需要它：

   • 一个解释是 updates （ weight gradients 乘以学习率）变得太小而无法用 FP16 表示。FP16 中任何 magnitude 小于 $2^{-24}$$2^{-24}$ 的值都会变成零。如 Figure 2b 所示，约 5% 的 weight gradient values的 exponents 小于 -24 。在 optimizer 中，这些小的梯度与学习率相乘后会变成零，并对模型准确率产生不利影响。使用 single-precision copy 进行更新可以克服这个问题并恢复准确率。

     即，weight updates 绝对很小，导致 updates 变成零。

   • 另一个解释是 weight value 与 weight update 的比率非常大。在这种情况下，即使 weight update 可以用 FP16 来表示，当加法操作将 weight update 右移从而将 binary point 与 weights 对齐时， weight update 仍然可能变成零。当 normalized weight value 的 magnitude 比 weight update 的 magnitude 大至少 2048 倍时，这种情况可能发生。由于FP16 有 10-bit 尾数，implicit bit 必须右移 11 位或更多位才可能创建零（在某些情况下，rounding 可以恢复该值）。在比率大于 2048 的情况下，implicit bit 将右移 12 位或更多位。这将导致 weight update 变成无法恢复的零。更大的比率将对 de-normalized 数字产生这种效应。同样，这种效应可以通过在 FP32 中计算 weight update 来抵消。

     即，weight updates 相对 weight 很小，导致训练效率很低（即，每个 step 中，权重的变化幅度非常小）。

   为了说明权重的 FP32 master copy 的必要性，我们使用了 Mandarin 语音模型在约 800 小时的语音数据上训练 20 epochs 。如Figure 2a 所示，当在 FP16 forward and backward passes 之后更新 FP32 master copy of weights 时，我们匹配了 FP32 training 结果；而更新 FP16 weights 则导致 80% 的相对 accuracy loss 。

   

3. 尽管与 single precision training 相比，维护额外的权重副本将权重的内存需求增加了 50% ，但对整体内存使用的影响要小得多。 对于训练，内存消耗主要由 activations 引起，这是由于较大的 batch size 、以及保存每层的 activations 从而在反向传播中重用。 由于 activations 也以半精度格式存储，所以整体内存消耗约减半。

   作者这里并未给出数据来说明。

1.1.2 Loss Scaling

1. FP16 exponent 将 normalized value exponents 范围有偏地居中到 [-14,15] ，而实际梯度值往往以小 magnitudes （ negative exponents ）为主。例如，考虑 Figure 3，显示了在 FP32 训练 Multibox SSD 检测器网络过程中收集的所有层的 activation gradient values 的直方图。注意，FP16 可表示范围的大部分未被使用，而许多值低于最小可表示范围并变为零。 scaling up 梯度将使它们占用更多的可表示范围，并保留一些值（如果不 scaling up，这些值将会因为零而丢失）。

   不缩放梯度时，该特定网络会发散；但将其缩放 8 倍（对 exponents 增加 3 ）足以匹配 FP32 training 达到的准确率。这表明，在 magnitude 上小于 $2^{-27}$$2^{-27}$ 的activation gradient values 对此模型的训练无关，但 $[2^{-27},2^{-24})$$[2^{-27}, 2^{-24})$ 范围内 magnitude 的 activation gradient values 很重要。

   由于学习率通常很小，因此 $[2^{-27},2^{-24})$$[2^{-27}, 2^{-24})$ 范围内的activation gradient values 乘以学习率仍然可能小于 $2^{-27}$$2^{-27}$ 。但是，Weight Update 采用 FP32，因此不会变为零。

   

2. 将 gradient values 移至 FP16 可表示范围的一种有效方法是：在开始反向传播之前，缩放在前向传播中计算的 loss value 。通过链式法则，反向传播将确保所有梯度值被缩放相同的量。这在反向传播期间不需要额外的操作，并使相关的梯度值不会变成零。

   在权重更新之前，必须 unscale 权重梯度，从而保持 weight update magnitudes 与 FP32 training 相同。最简单的方法是：在反向传播结束之后、但在梯度裁剪或任何其他与梯度相关的计算之前进行 unscale ，从而确保不需要调整任何超参数（如梯度裁剪阈值、weight decay 等）。

   虽然可以通过缩小学习率来间接地缩放梯度，但是梯度裁剪阈值、weight decay 等等方法的超参数也需要相应地缩放。

3. loss scaling factor 有几种选择。最简单的一种是选择一个常量的 scaling factor 。我们用 8 到 32K 的 scaling factor 训练了各种网络（许多网络不需要 scaling factor ）。可以经验性地选择一个常量 scaling factor ，或者如果有梯度统计信息，可以直接选择一个 scaling factor 使其与 maximum absolute gradient value 的乘积低于 65,504 （FP16 中可表示的最大值）。

   只要不在反向传播期间导致数值溢出，选择一个大的 scaling factor 就没有坏处。数值溢出会导致 weight gradients 中出现无穷大和 NaN ，在权重更新后会不可逆地破坏权重。请注意，数值溢出可以通过检查计算到的 weight gradients （例如在 unscale weight gradient values 的时候）来有效检测。一种解决方法是：在检测到数值溢出时跳过 weight update ，直接进入下一次迭代。

1.1.3 算术精度

1. 在很大程度上，神经网络的算术分为三类：向量点积、reductions 、以及 point-wise 操作。这些算术类别在 reduced precision 算术方面受益于不同的处理。

   • 为了保持模型准确率，我们发现一些网络要求 FP16 vector dot-product 从而累积 partial products 到 FP32 值，然后在写入内存前将其转换为 FP16 。如果不这样累积到 FP32 ，一些 FP16 模型的准确率无法匹配 baseline 模型。而先前的 GPU 只支持 FP16 multiply-add 操作，而 NVIDIA Volta GPU 引入了 Tensor Core ，可以将 FP16 的 输入矩阵相乘并累积乘积结果到 FP16 output 或 FP32 output 。

   • 大型的 reductions（如向量元素之和）应在 FP32 中进行。这种 reductions 主要出现在 batch-normalization layers （累积统计信息）和 softmax layers 。在我们的实现中，这两种 layer 类型仍从内存读取和写入 FP16 张量，而在 FP32 中执行算术运算。这并没有减慢训练过程，因为这些 layers 受内存带宽限制，而对于算术速度不敏感。

   • point-wise 操作（如非线性激活函数、element-wise 矩阵乘法）受内存带宽限制。由于算术精度不影响这些操作的速度，可以使用 FP16 或 FP32 。

1.2 实验

1. 略（参考原始论文）。

二、Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference[2017] [粗读]

论文：《Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference》

论文是关于量化 CNN 模型的，这里仅做粗读，仅关注核心算法。

1. Introduction：略（参考原始论文）。

2. 相关工作：略（参考原始论文）。

2.1 Quantized Inference

2.1.1 量化方案

1. 在这一节中，我们描述了通用的量化方案，也就是两种类型数值之间的对应关系： bit representation of values（这个整数记为 $q$$q$ ，表示"quantized value"）、以及它们作为数学的实数的解释（对应的实数记为 $r$$r$ ，表示 "real value"）。我们的量化方案在推理时只使用整数算术实现，在训练时使用浮点算术实现，两种 implementations 高度对应。我们首先数学上严格定义量化方案，然后分别采用该方案用于 integer-arithmetic inference 和 floating-point training 。

   floating-point training 类似于量化感知训练 Quantization Aware Training，即在训练阶段就应用 “模拟” 量化操作，从而降低 integer-arithmetic inference 的量化误差。

2. 我们量化方案的一个基本要求是，它允许只使用整数算术操作对 quantized values 进行所有算术运算的有效实现（我们避免需要 lookup tables 的实现，因为它们往往比在 SIMD 硬件上进行纯算术运算表现更差）。这相当于要求量化方案是整数 $q$$q$ 到实数 $r$$r$ 的仿射映射，即形式为：

   $$\begin{array}{}\text{(1)}& r=S(q-Z)\end{array}$$

   其中：$S$$S$ 和 $Z$$Z$ 为某些常量。

   • 常数 $S$$S$ （表示 "scale" ）是一个任意的正实数。它通常以软件中的浮点数形式表示，类似于实数 $r$$r$ 。本文后续内容描述了避免在推理工作中表示这种浮点数的方法。

   • 常数 $Z$$Z$ （表示"zero-point" ）与 quantized value $q$$q$ 的类型相同，事实上是对应于实数 $0$$0$ 的 quantized value $q$$q$ 。这自动满足以下要求：实数 $r=0$$r=0$ 可以被 quantized value 精确地表示。这一要求的动机是，高效实现的神经网络算子通常需要对数组进行 zero-padding 。

   这个公式是我们的量化方案，常数 $S$$S$ 和常数 $Z$$Z$ 是我们的量化参数（quantization parameters）。我们的量化方案对每个 activations array内的所有值、以及 weights array 内的所有值使用单组量化参数，即：不同的 array 使用独立的量化参数。

   对于 8-bit 量化，$q$$q$ 被量化为 8-bit 整数（对于 B-bit 量化，$q$$q$ 被量化为 B-bit 整数）。一些数组（通常是 bias vectors ）被量化为 32-bit 整数，参见后续内容。

3. 到目前为止的讨论被总结在以下的 quantized buffer 数据结构中，神经网络中的每个 activations array 和 weights array 都有这样一个 buffer 实例。我们使用 C++ 语法是因为它可以明确地表达类型：

   xxxxxxxxxx
   template<typename QType> // e.g. QType=uint8
   struct QuantizedBuffer {
     vector<QType> q; // the quantized values
     float S; // the scale
     QType Z; // the zero-point
   };
   

2.1.2 仅整数算术的矩阵乘法

1. 我们现在考虑如何仅使用整数算术进行推理，也就是如何使用方程 $r=S(q-Z)$$r = S(q-Z)$ 将实数运算翻译成 quantized-values 运算，以及后者如何设计为仅包含整数算术，即使 scaling 参数 $S$$S$ 是浮点数不是整数。

2. 考虑两个 $N\times N$$N\times N$ 的实数矩阵 ${\mathbf{R}}_1$$\mathbf R_1$ 和 ${\mathbf{R}}_2$$\mathbf R_2$ 的乘法，其矩阵乘积表示为 ${\mathbf{R}}_3={\mathbf{R}}_1{\mathbf{R}}_2$$\mathbf R_3 = \mathbf R_1\mathbf R_2$ 。我们将每个矩阵 ${\mathbf{R}}_{\alpha }$$\mathbf R_\alpha$ （$\alpha =1,2,3$$\alpha=1,2,3$）的项表示为 $r_{\alpha }^{(i,j)}$$r_\alpha^{(i,j)}$，其中 $1\le i,j\le N$$1\le i,j\le N$。对应的 quantized 矩阵为 ${\mathbf{Q}}_a$$\mathbf Q_a$，每一项表示为 $q_a^{(i,j)}$$q_a^{(i,j)}$。对应的量化参数为 $(S_{\alpha },Z_{\alpha })$$(S_\alpha,Z_\alpha)$。则方程 $r=S(q-Z)$$r = S(q-Z)$ 则变为：

   $$\begin{array}{}\text{(2)}& r_{\alpha }^{(i,j)}=S_{\alpha }(q_{\alpha }^{(i,j)}-Z_{\alpha })\end{array}$$

   从矩阵乘法的定义，我们有：

   $$\begin{array}{}\text{(3)}& S_3(q_3^{(i,k)}-Z_3)=\sum _{j=1}^N\left[S_1(q_1^{(i,j)}-Z_1)S_2(q_2^{(j,k)}-Z_2)\right]\end{array}$$

   这可以重写为：

   $$\begin{array}{}\text{(4)}& q_3^{(i,k)}=Z_3+M\sum _{j=1}^N\left[(q_1^{(i,j)}-Z_1)(q_2^{(j,k)}-Z_2)\right]\end{array}$$

   其中乘数 $M$$M$ 定义为：

   $$\begin{array}{}\text{(5)}& M=\frac{S_1{S}_2}{S_3}\end{array}$$

3. $q_3^{(i,k)}$$q_3^{(i,k)}$ 的方程中，唯一的非整数是乘数 $M$$M$ 。作为仅依赖于 quantization scales $S_1$$S_1$、$S_2$$S_2$ 、$S_3$$S_3$ 的常数，它可以离线计算。我们经验性地发现它总是在区间 $(0,1)$$(0,1)$ 内，因此可以表示为归一化的形式：

   $$\begin{array}{}\text{(6)}& M=2^{-n}{M}_0\end{array}$$

   其中：其中 $M_0$$M_0$ 在区间 $[0.5,1)$$[0.5,1)$ 内，$n$$n$ 为非负整数。

   • 归一化的乘数 $M_0$$M_0$ 现在很适合表示为定点乘数（例如根据硬件能力，采用 int16 或 int32 ）。例如，如果使用 int32 的整数乘法，表示 $M_0$$M_0$ 的整数是最接近 $2^{31}\times M_0$$2^{31}\times M_0$ 的 int32 值。由于 $M_0>0.5$$M_0 \gt 0.5$ ，这个值总是至少 $2^{30}$$2^{30}$ ，因此总是有至少 30-bit 的相对精度。因此，乘以 $M_0$$M_0$ 的乘法可以实现为定点乘法（fixed-point multiplication）。

   • 同时，乘以 $2^{-n}$$2^{-n}$ 的乘法可以实现为有效的移位运算（bit-shift ），尽管需要具有正确的四舍五入（round-to-nearest ）行为，我们在附录 B 中讨论这个问题。

2.1.3 高效处理 ZeroPoint

1. 为了在不执行 $2N^3$$2N^3$ 次减法、并且不将乘法操作数展开成 16-bit 整数的情况下，有效地实现公式 $q_3^{(i,k)}$$q_3^{(i,k)}$ 的求值，我们首先注意到通过在公式 $q_3^{(i,k)}$$q_3^{(i,k)}$ 中分配乘法，我们可以重写为：

   $$\begin{array}{}\text{(7)}& q_3^{(i,k)}=Z_3+M(N{Z}_1{Z}_2-Z_1{\overline{a}}_2^k-Z_2{\overline{a}}_1^{(i)}+\sum _{j=1}^N{q}_1^{(i,j)}{q}_2^{(j,k)})\end{array}$$

   其中：

   $$\begin{array}{}\text{(8)}& {\overline{a}}_2^{(k)}=\sum _{j=1}^N{q}_2^{(j,k)},{\overline{a}}_1^{(i)}=\sum _{j=1}^N{q}_1^{(i,j)}\end{array}$$

   每个 ${\overline{a}}_2^{(k)}$$\bar a_2^{(k)}$ 或 ${\overline{a}}_1^{(i)}$$\bar a_1^{(i)}$ 只需要 $N$$N$ 次加法来计算，所以总共只需要 $2N^2$$2N^2$ 次加法。

   上式的剩余成本几乎全部集中在核心的整数矩阵乘法累加上：

   $$\begin{array}{}\text{(9)}& \sum _{j=1}^N{q}_1^{(i,j)}{q}_2^{(j,k)}\end{array}$$

   这需要 $2N^3$$2N^3$ 次算术运算。

   的确，$q_3^{(i,k)}$$q_3^{(i,k)}$ 的新公式中的所有其他运算都是 $O(N^2)$$O(N^2)$，其中 $O$$O$ 中的常数很小。因此，展开成上述新公式的形式、以及分解为计算 ${\overline{a}}_2^{(k)}$$\bar a_2^{(k)}$ 和 ${\overline{a}}_1^{(i)}$$\bar a_1^{(i)}$ ，使得对于任意 zero-points 都能以很小的开销处理，除了 $N$$N$ 非常小的情况；问题简化为相同的 core integer matrix multiplication accumulation，因为我们在任何其他 zero-points-free 方案中都必须计算它。

   这仅仅改善了减法操作，而没有改善乘法操作。

   • 原始方法中，对于 ${\mathbf{Q}}_3$$\mathbf Q_3$ ，一共需要 $2N^3$$2N^3$ 的减法操作；但是新的方法中，计算 ${\left\{{\overline{a}}_2^{(k)}\right\}}_{k=1}^N$$\left\{\bar a_2^{(k)}\right\}_{k=1}^{N}$ 需要 $N^2$$N^2$ 次加法操作。然后 ${\overline{a}}_2$$\bar a_2%{(k)}$ 可以在不同的 $q_3^{(\cdot ,k)}$$q_3^{(\cdot,k)}$ 中共享。

   • 但是，对于乘法操作，二者之间并未改善。

2.1.4 典型 fused layer 的实现

1. 我们继续前面的讨论，但现在显式地定义所有涉及的量（quantities ）的数据类型，并修改 quantized 的矩阵乘法，从而直接将 bias-addition 和 activation function evaluation 合并到其中。这样将整个 layer 融合成单个操作而不仅是一个优化。由于我们必须在推理代码中重现训练中使用的相同算术，推理代码中的 fused operators 的粒度（接受 8-bit quantized input 并产生 8-bit quantized output ）必须与训练图中 "fake quantization" operators的 placement 相匹配。

   对于 ARM 和 x86 CPU 架构，我们使用 gemmlowp 库（《gemmlowp: a small self-contained low-precision gemm library》），其 GemmWithOutputPipeline 入口点支持我们现在描述的 fused operations 。

   General Matrix Multiplication: GEMM ：通用矩阵乘法。

2. 我们将 ${\mathbf{Q}}_1$$\mathbf Q_1$ 矩阵设为权重、${\mathbf{Q}}_2$$\mathbf Q_2$ 矩阵设为 activations 。权重和 activations 均为 uint8 类型（我们也可以等效地选择 int8 ，适当修改 zero-points ）。uint8 值的乘积的累加需要 32-bit accumulator ，我们为 accumulator 选择带符号类型，原因很快就会变清楚。 $\sum _{j=1}^N{q}_1^{(i,j)}{q}_2^{(j,k)}$$\sum_{j=1}^N q_1^{(i,j)} q_2^{(j,k)}$ 中的求和因此具有如下形式：

   $$\begin{array}{}\text{(10)}& \text{int32}=\text{unit8 }\times \text{ unit8 }\end{array}$$

   为了得到 quantized bias-addition （将 int32 bias 添加到 int32 accumulator 上），bias-vector 被量化为：

   • 使用 int32 作为其量化数据类型。

   • 使用 0 作为其 quantization zero-point $Z_{\text{bias}}$$Z_\text{bias}$ 。

   • 其 quantization scale $S_{\text{bias}}$$S_\text{bias}$ 与 accumulators 的相同，即 weights scale 和 input activations scale 的乘积：

     $$\begin{array}{}\text{(11)}& S_{\text{bias}}=S_1{S}_2,Z_{\text{bias}}=0\end{array}$$

   尽管 bias-vectors 被量化为 32-bit 值，但它们只占神经网络参数的很小一部分。此外，对 bias vectors 使用更高精度满足了一个真正的需求：由于每个 bias-vector entry 被添加到许多 output activations 中，bias-vector 中的任何量化误差往往表现为一个 overall bias （即，均值不为零的误差项），这必须避免以保持端到端的神经网络准确性。

   即，对于任何样本 $\mathbf{X}$$\mathbf X$ ， bias-vector 都添加到它的 output activation 上，因此 bias-vector 对所有样本都产生了影响。

3. 对 int32 accumulator 的最终值，还剩下三件事要做：

   • scale down 到 final scale，这个 final scale 被 8-bit output activations 所使用。

   • cast down 到 unit8 。

   • 应用 activation function 生成 final 8-bit output activation 。

   下采样对应于乘数 $M$$M$。如前所述，它实现为由归一化的乘数 $M_0$$M_0$ 的定点乘法、以及 rounding bit-shift 组成。之后，我们执行 cast 到 uint8 ，饱和到 [0,255] 范围。

   我们仅仅关注 clamps 类型的激活函数，例如 ReLU 、ReLU6 。数学函数在附录 A.1 中讨论，目前我们不会将它们融合到这种层中。因此，我们 fused activation functions 唯一需要做的就是进一步将 uint8 值截断到 [0,255] 的某个子区间，然后存储 final uint8 output activation。实际上，quantized training process （参考下一节）倾向于学习使用整个 output uint8 区间 [0,255] ，以致 activation function 不再起任何作用，其效果被归因于截断到区间 [0, 255] （由于 cast 到 unit8 所隐含的）。

2.2 Training with simulated quantization

在大模型时代，通常很少采用 simulated quantization 的训练，而是直接训练一个大模型，然后再进行 post-training 量化。

1. 训练 quantized networks 的常见方法是：用浮点进行训练，然后量化所得到的权重（有时伴随额外 post-quantization training 从而进行微调）。我们发现，这种方法对具有相当表达能力的大型模型效果足够好，但对小型模型会导致明显的准确率下降。simple post-training quantization 的常见失败模式包括：

   • 1) ：不同 output channels 的权重范围差异很大（大于 100 倍）。注意：前面章节中规定，同一层的所有通道必须量化到相同分辨率；这会导致权重范围较小的通道中，权重的相对误差更大。

   • 2) ：outlier weight values，这些异常值使得量化后所有的非异常值的权重降低了精确性。

2. 我们提出了一种在训练的前向传播中模拟量化效应（quantization effects ）的方法。反向传播仍然照常进行，所有权重和 bias 以浮点存储，以便可以轻易地略微调整。但是，前向传播模拟 quantized inference （因为 quantized inference 发生在推理引擎中），通过如下方式：以浮点算法实现我们前面介绍的量化方案中的 rounding behavior 。

   • 权重在与 input 执行卷积之前被量化。如果 layer 使用 batch normalization ，则在量化之前，batch normalization 参数被 “折叠”到权重中。

   • activations 在这样的时点上被量化：在推理期间 activations 被量化的点。例如：在 activation function 应用于卷积层或全连接层输出之后、或在像 ResNet 中那样多个层的输出相加或拼接的 bypass connection 之后。

   对于每一层，quantization 由 quantization levels 数量、以及 clamping range 的参数化，并通过 point-wise 地应用下面定义的量化函数 $q$$q$ 来执行：

   $$\begin{array}{}\text{(12)}& \begin{array}{c}\text{clamp}(r;a,b)=min(max(r,a),b),a\le b\\ s(a,b,n)=\frac{b-a}{n-1}\\ q(r;a,b,n)=\lfloor \frac{\text{clamp}(r;a,b)-a}{s(a,b,n)}\rceil \times s(a,b,n)+a\end{array}\end{array}$$

   其中：$r$$r$ 是要被量化的实值数；$[a;b]$$[a;b]$ 是量化范围；$n$$n$ 是 quantization levels 数量；$\lfloor \cdot \rceil$$\lfloor\cdot \rceil$ 表示四舍五入到最近的整数。

   在我们的实验中，$n$$n$ 对所有层固定，例如 8-bit 量化时 $n=2^8=256$$n = 2^8 = 256$ 。

   即，在原始的神经网络中插入这些特定的 fake quantization layer 。

2.2.1 学习 quantization ranges

1. weight quantization与 activation quantization 的 quantization ranges 的处理不同：

   • 对于权重，基本思想是：简单地设置 $a=min(\mathbf{W});b=max(\mathbf{W})$$a=\min(\mathbf W); b=\max(\mathbf W)$，其中 $\mathbf{W}$$\mathbf W$ 为权重矩阵。我们对此稍作调整，使得权重一旦被量化为 int8 值，取值范围仅仅在 [-127, 127] 并且不会取值为 -128 ，因为这 enable 了一个重要的 optimization opportunity （更多细节见附录 B ）。

   • 对于 activations ，ranges 取决于网络输入。为了估计 ranges ，我们在训练期间收集 activations 上的 [a; b] 范围，然后通过指数移动平均（exponential moving averages: EMA ）聚合它们，平滑参数接近 1 ，以便 observed ranges在数千步训练中平滑。鉴于在 ranges 快速变化时，EMA 更新 activation ranges有明显延迟，我们发现在训练开始时完全禁用 activation quantization 很有用（例如前 50K 步到 2M 步）。这使网络进入更稳定状态，其中 activation quantization ranges 不会排除 values 的重要部分。

     这类似于 Batch Normalization 的思想。在训练中自动更新 activation ranges 。

   在两种情况下，都会调整 [a; b] 的边界，以便值 0.0 在量化后可以精确表示为整数 $z(a,b,n)$$z(a,b,n)$。因此，学到的 quantization parameters 映射到方程 $r=S(q-Z)$$r=S(q-Z)$ 中的 scale $S$$S$ 和 zero-point $Z$$Z$ ：

   $$\begin{array}{}\text{(13)}& S=s(a,b,n),Z=z(a,b,n)\end{array}$$

2. 下面我们假设神经网络的计算被捕获为 TensorFlow graph ，然后描述 simulated quantization 。典型的工作流程在 Algorithm 1 中描述。通过 fusing and removing operations 的inference graph 的优化，超出了本文范围。用于 graph modifications 的源码（插入 fake quantization 操作、创建和优化 inference graph）、以及 low bit inference engine 已在 《Tensorflow quantized training support》 中通过 TensorFlow contributions 开源。

   公式 12 为：

   $$\begin{array}{}\text{(14)}& \begin{array}{c}\text{clamp}(r;a,b)=min(max(r,a),b),a\le b\\ s(a,b,n)=\frac{b-a}{n-1}\\ q(r;a,b,n)=\lfloor \frac{\text{clamp}(r;a,b)-a}{s(a,b,n)}\rceil \times s(a,b,n)+a\end{array}\end{array}$$

   

3. Figure 1.1 a and b 说明了一个简单卷积层量化前后的 TensorFlow graph 。Figure C.3 中，更复杂的带 bypass connection 的卷积的说明，可以在 Figure C.4 中找到。

   请注意，bias 没有被量化，因为在推理过程中它们表示为 32-bit 整数，范围和精度远高于 8-bit weights and activations。此外，用于，bias 的量化参数从权重和激活的量化参数推导出来。

   使用《Tensorflow quantized training support》 的典型 TensorFlow 代码示例如下：

   xxxxxxxxxx
   from tf.contrib.quantize import quantize_graph as qg
   g = tf.Graph()
   with g.as_default():
     output = ...
     total_loss = ...
     optimizer = ...
     train_tensor = ...
     
   if is_training:
     quantized_graph = qg.create_training_graph(g)
   else:
     quantized_graph = qg.create_eval_graph(g)
   # Train or evaluate quantized_graph.
   

   

   

   

2.2.2 Batch normalization folding

1. 对于使用 batch normalization 的模型，存在额外复杂性：training graph 中 batch normalization是单独的操作块，而 inference graph 中 batch normalization 参数 “折叠” 到卷积层或全连接层的权重和 bias 中，从而提高效率。为了准确模拟量化效应，我们需要模拟这种折叠，并在权重被 batch normalization parameters 缩放后再来量化权重。我们采用以下方法：

   $$\begin{array}{}\text{(15)}& w_{\text{fold}}=\frac{\gamma w}{\sqrt{\text{EMA}\left({\sigma }_B^2\right)+ϵ}}\end{array}$$

   其中：

   • $\gamma$$\gamma$ 为 batch normalization 的 scale 参数。

   • $\text{EMA}\left({\sigma }_B^2\right)$$\text{EMA}\left(\sigma_B^2\right)$ 为 convolution results 的 batch 内方差的移动平均估计。

   • $ϵ$$\epsilon$ 是一个小常数用于数值稳定性。

   折叠后，batch-normalized convolutional layer 简化为 Figure 1.1a 中所示的简单卷积层，具有被折叠的权重 $w_{\text{fold}}$$w_\text{fold}$ 、以及相应的被折叠的 bias 。因此，相同的配方也适用于 Figure 1.1b 。附录中可以查阅 batch-normalized convolutional layer （ Figure C.5 ）、相应的 inference graph （Figure C.6 ）、batch-norm folding 后的训练图（ Figure C.7 ）以及 folding and quantization 后的训练图（ Figure C.8 ）。

   

   

2.3 实验

1. 略（参考原始论文）。

三、LLM.int8()[2022]

论文：《LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale》

1. 大型 pretrained 语言模型在 NLP 中被广泛采用，但需要大量内存进行推理。对于超过 6.7B 参数的大型 transformer 语言模型，前馈层（feed-forward layer ）和注意力投影层（attention projection layer）及其矩阵乘法操作占据了 95% 的参数和 65-85% 的所有计算（《High performance natural language processing》）。减小参数大小的一种方法是将其量化为更少的比特并使用低位精度（low-bit-precision ）的矩阵乘法。考虑到这一目标，人们已经开发了 transformer 的 8-bit 量化方法。虽然这些方法减少了内存使用，但它们降低了性能，通常需要在训练后进一步 tuning quantization，并且只在少于 350M 参数的模型上进行了研究。低于 350M 参数时性能无损的量化理解得不够好，十亿参数级的量化仍是一个开放性挑战。

   在本文中，我们提出了第一个不降低性能的十亿参数级 Int8 量化过程。我们的过程使得加载一个具有 16-bit 或 32-bit 参数的 175B 参数的 transformer ，将前馈层和注意力投影层转换为 8-bit，并立即用于推理而不降低任何性能。我们通过解决两个关键挑战实现了这一结果：

   • 大于 1B 参数时需要更高的量化精度（quantization precision ）。

   • 需要明确表示稀疏的但系统性的大幅值的异常值特征（sparse but systematic large magnitude outlier features），在所有的 transformer 层（从 6.7B 参数规模开始）中，这些特征一旦出现就会破坏量化精度。一旦这些异常值特征出现，C4 evaluation perplexity 以及 zero-shot accuracy 就会反映出这种精度损失（loss of precision ），如 Figure 1 所示。

   

   我们证明，通过我们方法的第一部分向量化量化（vector-wise quantization），可以在高达 2.7B 参数的规模下保持性能。对于向量化量化，矩阵乘法可以看作是行向量序列和列向量序列的独立内积序列。因此，我们可以为每个内积使用单独的量化归一化常数（quantization normalization constant）来提高量化精度。我们可以通过在执行下一个操作之前用列归一化常数和行归一化常数的外积对矩阵乘法的输出进行反归一化（denormalizing）来恢复矩阵乘法的输出。

   为了在不降低性能的情况下扩展到超过 6.7B 的参数，理解推理过程中隐状态（隐状态就是 activation ）feature dimensions中的极端异常值的出现至关重要。为此，我们提供了一个新的描述性分析，该分析显示：

   • 在将 transformer 扩展到 6B 参数时，所有 transformer 层中大约 25% 首先出现了幅度高达其他维度 20 倍的大特征（large features ），然后这些大特征逐渐传播到其他层。

   • 在大约 6.7B 参数时，发生了一个phase shift ，所有 transformer 层、以及 75% 的所有sequence dimensions都受到极端幅度的特征（extreme magnitude features）的影响。这些异常值高度地系统化（systematic）：在 6.7B 规模下，每个序列有 150,000 个异常值，但它们集中在整个 transformer 中的仅 6 个feature dimensions中。

     将这些异常feature dimensions设置为零会使 top-1 attention softmax 概率质量降低 20% 以上，并使 validation perplexity 退化 600-1000% ，尽管它们只占所有输入特征的约 0.1% 。相比之下，删除相同数量的随机特征会最大降低 0.3% 的概率质量，并退化约 0.1% 的困惑度（perplexity）。

   给定一个文本序列，sequence 维度表示 token id 的维度，feature 表示 embedding 或 activation 的维度。上述描述的含义是：

   • 在 6B 模型，有 25% 的层（$l=1,\cdots ,L$$l=1,\cdots,L$）出现了异常值。

   • 在 6.7B 模型，所有的层出现了异常值；沿着 token id 的方向，有 75% 的位置出现了异常值（ $s=1,\cdots ,S$$s=1,\cdots,S$）；沿着 embedding/activation 的方向，有 6 个位置出现了异常值（$i=1,\cdots ,d$$i=1,\cdots,d$）。

   写成矩阵的形式：

   $$\begin{array}{}\text{(16)}& \begin{array}{c}{\mathbf{H}}_1=\left[\begin{array}{cccc}{h}_{1,1}^{(1)}& h_{1,2}^{(1)}& \cdots & h_{1,d}^{(1)}\\ h_{2,1}^{(1)}& h_{2,2}^{(1)}& \cdots & h_{2,d}^{(1)}\\ ⋮& ⋮& \ddots & ⋮\\ h_{S,1}^{(1)}& h_{S,2}^{(1)}& \cdots & h_{S,d}^{(1)}\end{array}\right],\cdots ,{\mathbf{H}}_L=\left[\begin{array}{cccc}{h}_{1,1}^{(L)}& h_{1,2}^{(L)}& \cdots & h_{1,d}^{(L)}\\ h_{2,1}^{(L)}& h_{2,2}^{(L)}& \cdots & h_{2,d}^{(L)}\\ ⋮& ⋮& \ddots & ⋮\\ h_{S,1}^{(L)}& h_{S,2}^{(L)}& \cdots & h_{S,d}^{(L)}\end{array}\right]\in {\mathbb{R}}^{S\times d}\end{array}\end{array}$$

   为了支持这样极端异常值的有效量化，我们开发了混合精度分解（mixed-precision decomposition），即我们方法的第二部分。 我们对异常feature dimensions执行 16-bit 矩阵乘法、对其余 99.9% 的维度执行 8-bit 矩阵乘法。我们将向量化量化、以及混合精度分解的组合命名为 LLM.int8() 。 我们证明，通过使用 LLM.int8() ，我们可以在具有多达 175B 参数的 LLM 上进行推理，而不降低任何性能。我们的方法不仅为这些异常值对模型性能的影响提供了新的见解，而且还首次使非常大的模型（例如 OPT-175B/BLOOM ）能够在具有消费级 GPU 的单服务器上使用。虽然我们的工作重点是在不降低性能的情况下使大型语言模型可访问，但我们在附录 D 中还展示了我们为大型模型（如 BLOOM-176B ）维持端到端 inference runtime 性能，并为大于或等于 6.7B 参数的 GPT-3 模型提供了适度的矩阵乘法速度提升。我们开源了我们的软件，并发布了 Hugging Face Transformers 集成，使我们的方法可用于 Hugging Face Models 托管的所有具有线性层的模型。

   可以看到，LLM.int8() 仅在较大的模型（模型规模大于 6.7B ）时才会加速推断；在更小的模型时，推断速度反而更慢（相比较于原始的 FP16 ）。

   

   

2. 相关工作：下面列出了 quantization data types 、以及 quantization of transformers 有密切相关的工作。附录 B 提供了有关 quantization of convolutional networks 的更多相关工作。

   • 8-bit Data Types：我们的工作研究围绕 Int8 数据类型的量化技术，因为它目前是 GPU 支持的唯一 8-bit 数据类型。其他常见的数据类型是定点 8-bit 数据类型或浮点 8-bit 数据类型（floating point 8-bit: FP8 ）。

     这些数据类型通常有一个符号位（ sign bit） 、以及指数位（ exponent bit ）和小数位（ fraction bit） 的不同组合。例如，这种数据类型的一个常见变体有 5 bits 指数、 2 bits 小数，并使用 zeropoint scaling 或者 no scaling constants 。由于这些数据类型对 fraction 只有 2 bits，所以对大的幅值（large magnitude ）有很大误差，但可以为小的幅值提供高精度。

     《F8net: Fixed-point 8-bit only multiplication for network quantization》 提供了出色的分析，关于对具有特定标准差的输入，在何时某些 fixed point exponent/fraction bit widths 是最佳的。我们认为 FP8 数据类型与 Int8 数据类型相比提供了优异的性能，但当前 GPU 和 TPU 都不支持此数据类型。

   • 语言模型中的异常值特征（Outlier Features ）：语言模型中大幅值异常值特征（large magnitude outlier features）的研究已经存在。

     • 先前的工作证明了 transformer 中异常值出现与 layer normalization 以及 token frequency distribution 的理论关系（《Representation degeneration problem in training natural language generation models》）。

     • 类似地，《Bert busters: Outlier dimensions that disrupt transformers》 将 BERT 模型族中异常值的出现归因于 LayerNorm 。

     • 《Outliers dimensions that disrupt transformers are driven by frequency》 在经验上表明异常值的出现与训练分布中 tokens 的频率有关。

     我们通过展示自回归模型的规模与这些异常值特征的 emergent properties 之间的关系，以及适当建模异常值对有效量化（effective quantization ）的重要性，从而来进一步扩展这项工作。

   • 十亿规模 transformer 的量化：与我们的工作相比，人们平行开发了两种方法：

     • nuQmm（《nuqmm: Quantized matmul for efficient inference of large-scale generative language models》）、以及 ZeroQuant （《Zeroquant: Efficient and affordable post-training quantization for large-scale transformers》）。两者使用相同的量化方案：分组向量化量化（group-wise quantization），其量化归一化常数粒度比向量量化更细。这种方案提供了更高的量化精度，但也需要自定义的 CUDA kernels 。

       • nuQmm 和 ZeroQuant 旨在加速推理和减少内存占用，而我们则关注在 8-bit 内存占用下保留预测性能。

       • nuQmm 和 ZeroQuant 评估的最大模型分别是 2.7B 和 20B 参数的 transformer 。ZeroQuant 实现了 20B 模型的 8-bit 量化，同时保持性能没有衰退。我们展示了我们的方法允许高达 176B 参数的模型进行 zero-degradation quantization 。nuQmm 和 ZeroQuant 表明，更细粒度的量化可以是大型模型量化的有效手段。这些方法与 LLM.int8() 是互补的。

     • 另一个平行工作是 GLM-130B ，它使用我们工作的见解实现 zero-degradation 8-bit quantization （《Glm-130b: An open bilingual pre-trained model》）。GLM-130B 以 8-bit weight storage 进行完整的16-bit 精度的矩阵乘法。

       相比之下，LLM.int8() 采用 8-bit 的矩阵乘法。

3.1 背景知识

1. 在这项工作中，我们通过扩展 transformer 模型将量化技术推向了极限。我们对两个问题感兴趣：

   • 在何种模型规模下量化技术会失败，以及为何量化技术会失败？

   • 量化技术的失败与量化精度有何关系？

   为了回答这些问题，我们研究了高精度非对称量化（zeropoint quantization ）和高精度对称量化（absolute maximum quantization ）。虽然 zeropoint quantization 通过使用数据类型的 full bit-range 提供了高精度，但由于实际限制而很少使用它。absolute maximum quantization 是最常用的技术。

3.1.1 8-bit 数据类型和量化

1. absmax 量化通过将输入乘以 $s_{X_{f16}}$$s_{X_{f16}}$ 从而缩放到 8-bit 范围 [-127, 127] 中。因此，对于 FP16 数据类型的输入矩阵 ${\mathbf{X}}_{f16}\in {\mathbb{R}}^{S\times h}$$\mathbf X_{f16}\in \mathbb R^{S\times h}$，Int8 absmax quantization 由以下公式给出：

   $$\begin{array}{}\text{(17)}& {\mathbf{X}}_{i8}=\lfloor \frac{127}{\underset{i,j}{max}(|X_{f16,i,j}|)}\times {\mathbf{X}}_{f16}\rceil =\lfloor \frac{127}{||{\mathbf{X}}_{f16}|{|}_{\mathrm{\infty }}}\times {\mathbf{X}}_{f16}\rceil =\lfloor s_{X_{f16}}\times {\mathbf{X}}_{f16}\rceil \end{array}$$

   其中：

   • $|\cdot |$$|\cdot|$ 表示绝对值，$\lfloor \cdot \rceil$$\left\lfloor \cdot\right\rceil$ 表示四舍五入到最近的整数。

   • $X_{f16,i,j}$$X_{f16,i,j}$ 表示 ${\mathbf{X}}_{f16}$$\mathbf X_{f16}$ 的第 $i$$i$ 行、$j$$j$ 列的元素。

   • $s_{X_{f16}}=\frac{127}{||{\mathbf{X}}_{f16}|{|}_{\mathrm{\infty }}}$$s_{X_{f16}} = \frac{127}{||\mathbf X_{f16}||_\infty}$ 为量化常数。

2. zeropoint 量化通过如下的方式将 input distribution 移动到 full range [-127, 127] 中：首先用 normalized dynamic range $n{d}_X$$nd_X$ 来缩放，然后用 zeropoint $z{p}_X$$zp_X$ 来移动。通过这种仿射变换（affine transformation ），任何输入张量都将使用数据类型的所有比特，从而减少非对称分布（asymmetric distributions ）的量化错误。例如，对于 ReLU 输出，在 absmax 量化中，所有 [-127, 0) 的值都未被使用；而在 zeropoint 量化中，完整范围 [-127,127] 都被使用。

   zeropoint 量化由以下等式给出：

   $$\begin{array}{}\text{(18)}& \begin{array}{c}n{d}_{X_{f16}}=\frac{2\times 127}{\underset{i,j}{max}(X_{f16,i,j})-\underset{i,j}{min}(X_{f16,i,j})}\\ z{p}_{X_{i16}}=\lfloor -n{d}_{X_{f16}}\times \frac{\underset{i,j}{max}(X_{f16,i,j})+\underset{i,j}{min}(X_{f16,i,j})}{2}\rceil \\ {\mathbf{X}}_{i8}=\lfloor n{d}_{X_{f16}}\times {\mathbf{X}}_{f16}\rceil +z{p}_{X_{i16}}\end{array}\end{array}$$

   推导过程：假设 $a=max(x),b=min(x),a\ge x\ge b$$a = max(x), b = min(x), a \ge x \ge b$ 。我们希望把 $x$$x$ 投影到 [-127, 127] 之间。则可以采用仿射变换：

   $$\begin{array}{}\text{(19)}& y=\frac{x-b}{(a-b)}\times (2\times 127)-127=x\times \frac{2\times 127}{a-b}-127\times \frac{a+b}{a-b}\end{array}$$

   然后根据 $q=\lfloor y\rceil$$q = \lfloor y\rceil$ 来进行量化。

   根据论文《Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference》，zeropoint 量化的形式为：

   $$\begin{array}{}\text{(20)}& x=\frac{1}{n{d}_{X_{f16}}}(q-zp)\simeq \frac{1}{n{d}_{X_{f16}}}(y-zp)\end{array}$$

   因此：

   $$\begin{array}{}\text{(21)}& n{d}_{X_{f16}}=\frac{2\times 127}{a-b},zp=-127\times \frac{a+b}{a-b}\end{array}$$

   逆量化为：${\mathbf{X}}_{f16}=\frac{1}{n{d}_{X_{f16}}}\times ({\mathbf{X}}_{i8}-zp)$$\mathbf X_{f16} = \frac{1}{nd_{X_{f16}}}\times (\mathbf X_{i8} - zp)$ 。

   要在操作中使用 zeropoint 量化，我们同时传入张量 ${\mathbf{X}}_{i8}$$\mathbf X_{i8}$ 和 zeropoint $z{p}_{X_{i8}}$$zp_{X_{i8}}$ 到一个特殊指令，该指令在执行 16-bit 整数操作之前，将$-z{p}_{X_{i8}}$$-zp_{X_{i8}}$ 添加到 ${\mathbf{X}}_{i8}$$\mathbf X_{i8}$ 的每个元素中。例如，要将两个 zeropoint quantized 数值 $A_{i8}$$A_{i8}$ 和 $B_{i8}$$B_{i8}$ （以及它们的零点 $z{p}_{A_{i8}}$$zp_{A_{i8}}$和 $z{p}_{B_{i8}}$$zp_{B_{i8}}$）相乘，我们计算：

   $$\begin{array}{}\text{(22)}& C_{i32}={\text{multiply}}_{i16}(A_{z{p}_{A_{i16}}},B_{z{p}_{B_{i16}}})=(A_{i8}-z{p}_{A_{i8}})\times (B_{i8}-z{p}_{B_{i8}})\end{array}$$

   如果没有 multiply_i16 指令，如在 GPU 或 TPU 上，则需要展开：

   $$\begin{array}{}\text{(23)}& C_{i32}=A_{i8}{B}_{i8}-A_{i8}z{p}_{B_{i8}}-B_{i8}z{p}_{A_{i8}}+z{p}_{A_{i8}}z{p}_{B_{i8}}\end{array}$$

   注意：结果是 32-bit 整数。

   其中：$A_{i8}{B}_{i8}$$A_{i8}B_{i8}$ 以 Int8 精度计算，其余以 Int16/32 精度计算。因此，如果没有 multiply_i16 指令，zeropoint 量化可能比较慢。

   在上述两种情况下，输出以32-bit 整数 $C_{i32}$$C_{i32}$ 累加。为了逆量化 $C_{i32}$$C_{i32}$ ，我们将其除以缩放常数 $n{d}_{A_{f16}}$$nd_{A_{f16}}$ 和 $n{d}_{B_{f16}}$$nd_{B_{f16}}$ 。

   即：

   $$\begin{array}{}\text{(24)}& A_{z{p}_{A_{f16}}}\times B_{z{p}_{B_{f16}}}=\frac{1}{n{d}_{A_{f16}}\times n{d}_{B_{f16}}}\times [(A_{i8}-z{p}_{A_{i8}})\times (B_{i8}-z{p}_{B_{i8}})]=\frac{1}{n{d}_{A_{f16}}\times n{d}_{B_{f16}}}\times C_{i32}\end{array}$$

3. 具有 16-bit 浮点输入和输出的 Int8 矩阵乘法：给定隐状态 ${\mathbf{X}}_{f16}\in {\mathbb{R}}^{S\times h}$$\mathbf X_{f16}\in \mathbb R^{S\times h}$ 和权重 ${\mathbf{W}}_{f16}\in {\mathbb{R}}^{h\times o}$$\mathbf W_{f16}\in\mathbb R^{h\times o}$，其中 $S$$S$ 为sequence dimensions、$h$$h$ 为feature dimensions、$o$$o$ 为输出维度，我们执行具有 16-bit 浮点输入和输出的 8-bit 矩阵乘法如下：

   $$\begin{array}{}\text{(25)}& \begin{array}{c}{\mathbf{X}}_{f16}{\mathbf{W}}_{f16}={\mathbf{C}}_{f16}\simeq \frac{1}{c_{X_{f16}}{c}_{W_{f16}}}\times {\mathbf{C}}_{i32}=s_{f16}\times {\mathbf{C}}_{i32}\\ =s_{f16}\times {\mathbf{X}}_{i8}{\mathbf{W}}_{i8}\simeq s_{f16}\times \mathcal{Q}({\mathbf{X}}_{f16})\mathcal{Q}({\mathbf{W}}_{f16})\end{array}\end{array}$$

   其中：

   • $c_{X_{f16}},c_{W_{f16}}$$c_{X_{f16}},c_{W_{f16}}$ 为 tensor-wise 的量化常数：

     • 对于 absmax 量化，它们分别为 $s_X$$s_X$ 和 $s_W$$s_W$ 。

     • 对于 zeropoint 量化，它们分别为 $n{d}_X,n{d}_W$$nd_X, nd_W$ 。

   • $s_{f16}=\frac{1}{c_{X_{f16}}{c}_{W_{f16}}}$$s_{f16} = \frac{1}{c_{X_{f16}}c_{W_{f16}}}$ 为新的量化常数，$\mathcal{Q}(\cdot )$$\mathcal Q(\cdot)$ 为 absmax 量化或 zeropoint 量化。

3.2 大规模的 Int8 矩阵乘法

1. 使用每个张量一个 scaling constant （即， scaling constant ）的量化方法的主要挑战是，单个异常值可以降低所有其他值的量化精度。因此，每个张量拥有多个 scaling constant 是可取的，比如 block-wise constants （《8-bit optimizers via block-wise quantization》），这样异常值的影响就局限于每个 block 。我们通过使用向量化量化（vector-wise quantization ）来改进 row-wise quantization （《Fbgemm: Enabling high-performance low-precision deep learning inference》），其中row-wise quantization 是最常见的 blocking quantization 方式之一，详细内容如下所述。

2. 为了处理超过 6.7B 规模的所有 transformer layers 中出现的大幅值异常值特征（large magnitude outlier features ），仅仅向量化量化是不够的。为此，我们开发了混合精度分解（mixed-precision decomposition），其中少量的大幅值的 feature dimensions（large magnitude feature dimensions），占比约 0.1% 以 16-bit 精度来表示，而其他 99.9% 的值以 8-bit 相乘。由于大多数元素仍以低精度来表示，与 16-bit 相比，我们仍保留约 50% 的内存减少。例如，对于 BLOOM-176B，我们将模型的内存占用降低了 1.96 倍。

3. Figure 2 显示了向量化量化和混合精度分解。LLM.int8() 方法是 absmax vector-wise quantization 和混合精度分解的组合。

   注意：$\mathbf{X}$$\mathbf X$ 按列分解，$\mathbf{W}$$\mathbf W$ 按行分解。为什么？因为异常值特征主要集中在 activation （即，$\mathbf{X}$$\mathbf X$）的少部分的列。而 $\mathbf{W}$$\mathbf W$ 通常不包含异常值。

   本文并没有理论指导，而是根据大模型的实验性分析从而得到的方法。

   

3.2.1 Vector-wise Quantization

1. 增加矩阵乘法的 scaling constants 的数量的一种方法是：将矩阵乘法视为独立内积的序列。给定隐状态 ${\mathbf{X}}_{f16}\in {\mathbb{R}}^{S\times h}$$\mathbf X_{f16}\in \mathbb R^{S\times h}$ 和权重 ${\mathbf{W}}_{f16}\in {\mathbb{R}}^{h\times o}$$\mathbf W_{f16}\in\mathbb R^{h\times o}$，我们可以为 ${\mathbf{X}}_{f16}$$\mathbf X_{f16}$ 的每一行分配不同的 scaling constants $c_{X_{f16}}$$c_{X_{f16}}$，并为 ${\mathbf{W}}_{f16}$$\mathbf W_{f16}$ 的每一列分配不同的 $c_{W_{f16}}$$c_{W_{f16}}$。为了逆量化，我们通过 $1/(c_{X_{f16}}{c}_{W_{f16}})$$1/(c_{X_{f16}}c_{W_{f16}})$ 来 denormalize 每个内积结果。对于整个矩阵乘法，这相当于通过外积 ${\overrightarrow{\mathbf{c}}}_{X_{f16}}\otimes {\overrightarrow{\mathbf{c}}}_{W_{f16}}$$\mathbf{\vec c}_{X_{f16}}\otimes \mathbf{\vec c}_{W_{f16}}$ 来 denormalize ，其中 ${\overrightarrow{\mathbf{c}}}_{X_{f16}}\in {\mathbb{R}}^S$$\mathbf{\vec c}_{X_{f16}}\in \mathbb R^S$ 、${\overrightarrow{\mathbf{c}}}_{W_{f16}}\in {\mathbb{R}}^o$$\mathbf{\vec c}_{W_{f16}}\in \mathbb R^o$。因此，具有行 scaling constants 和列 scaling constants 的矩阵乘法的完整方程如下：

   $$\begin{array}{}\text{(26)}& {\mathbf{C}}_{f16}\simeq \frac{1}{{\overrightarrow{\mathbf{c}}}_{X_{f16}}\otimes {\overrightarrow{\mathbf{c}}}_{W_{f16}}}\odot {\mathbf{C}}_{i32}=\mathbf{S}\odot {\mathbf{C}}_{i32}=\mathbf{S}\odot ({\mathbf{A}}_{i8}{\mathbf{B}}_{i8})=\mathbf{S}\odot (\mathcal{Q}({\mathbf{A}}_{f16})\mathcal{Q}({\mathbf{B}}_{f16}))\end{array}$$

   其中：

   • $\odot$$\odot$ 为逐元素乘法，$\mathcal{Q}(\cdot )$$\mathcal Q(\cdot)$ 为 absmax 量化。

   • $\mathbf{S}=\frac{1}{{\overrightarrow{\mathbf{c}}}_{X_{f16}}\otimes {\overrightarrow{\mathbf{c}}}_{W_{f16}}}$$\mathbf S = \frac{1}{\mathbf{\vec c}_{X_{f16}}\otimes \mathbf{\vec c}_{W_{f16}}}$ 为 scaling constants 矩阵。

   我们将其称为矩阵乘法的向量化量化。

   对于向量 $\overrightarrow{\mathbf{a}}\in {\mathbb{R}}^S,\overrightarrow{\mathbf{b}}\in {\mathbb{R}}^o$$\mathbf{\vec a}\in \mathbb R^S, \mathbf{\vec b}\in \mathbb R^o$，它们的外积定义为：

   $$\begin{array}{}\text{(27)}& \begin{array}{c}\overrightarrow{\mathbf{a}}\otimes \overrightarrow{\mathbf{b}}=\left[\begin{array}{cccc}{a}_1{b}_1& a_1{b}_2& \cdots & a_1{b}_o\\ a_2{b}_1& a_2{b}_2& \cdots & a_2{b}_o\\ ⋮& ⋮& \ddots & ⋮\\ a_S{b}_1& a_S{b}_2& \cdots & a_S{b}_o\end{array}\right]\in {\mathbb{R}}^{S\times o}\end{array}\end{array}$$

3.2.2 LLM.int8() 的核心: Mixed-precision Decomposition

1. 通过我们的分析，我们证明十亿级参数的 8-bit transformer 的一个重大问题是，它们具有大幅值特征（列），这对 transformer 性能非常重要，需要高精度量化。但是，我们的最佳量化技术（即，向量化量化）对每个隐状态行进行量化，这对异常值特征（outlier features ）无效。幸运的是，我们看到这些异常值特征在实践中非常稀疏且系统化，只占所有feature dimensions的约 0.1% ，因此允许我们开发一种新的分解技术，重点关注这些特定维度的高精度乘法。

   这段话的意思是，异常值是集中在输入 $\mathbf{X}$$\mathbf X$ 的某些列，而不是集中在 $\mathbf{X}$$\mathbf X$ 的某些行。因此，对 $\mathbf{X}$$\mathbf X$ 进行按行的 scaling constants 会受到异常值的影响。

2. 我们发现，给定输入矩阵 ${\mathbf{X}}_{f16}\in {\mathbb{R}}^{S\times h}$$\mathbf X_{f16} \in \mathbb R^{S\times h}$ ，这些异常值几乎对所有 row 系统性地出现，但局限于特定的列。因此，我们为矩阵乘法提出混合精度分解，其中我们将包含异常值的列分离到集合 $\mathcal{O}=\{i\mid i\in \mathbb{Z},0\le i\le h\}$$\mathcal O=\{i\mid i\in \mathbb Z, 0\le i\le h\}$，它包含至少有一个幅值大于阈值 $\alpha$$\alpha$ 的列。在我们的工作中，我们发现 $\alpha =6.0$$\alpha = 6.0$ 足以将transformer 的 performance degradation 减少到接近零。使用爱因斯坦记号，其中所有索引都是上标，给定权重矩阵 ${\mathbf{W}}_{f16}\in {\mathbb{R}}^{h\times o}$$\mathbf W_{f16}\in \mathbb R^{h\times o}$，矩阵乘法的混合精度分解定义如下：

   $$\begin{array}{}\text{(28)}& {\mathbf{C}}_{f16}=\sum _{i\in \mathcal{O}}{\mathbf{X}}_{f16}^i{\mathbf{W}}_{f16}^i+{\mathbf{S}}_{f16}\odot \sum _{j\notin \mathcal{O}}{\mathbf{X}}_{i18}^j{\mathbf{W}}_{i8}^j\end{array}$$

   其中：${\mathbf{S}}_{f16}$$\mathbf S_{f16}$ 是 denormalization 项。

   这种分离为 8-bit 和 16-bit 允许异常值的高精度乘法，同时使用内存高效的矩阵乘法，其中包含 8-bit 权重值（在所有权重值中占比 99.9% 以上）。由于异常值的列对于高达 13B 参数的 transformer 不超过7 （即，$|\mathcal{O}|\le 7$$|\mathcal O|\le 7$），这种分解操作仅消耗约0.1% 的额外内存。

3.2.3 实验设置

1. 我们随着模型规模的增加来衡量量化方法的稳健性，规模达到 175B 参数。关键问题不是某种量化方法对特定模型的表现如何，而是随着我们增加规模，这种方法的表现趋势如何。

   我们使用两种实验设置：

   • 一种基于语言建模困惑度（language modeling perplexity ），我们发现这是一种高度稳健的指标，对 quantization degradation 非常敏感。我们使用此设置来比较不同的 quantization baselines 。

     对于语言建模设置，我们使用在 fairseq 中预训练好的稠密的自回归 transformer ，参数范围在 125M 到 13B 之间。这些transformer 在 Books、English Wikipedia、CC-News、OpenWebText、CC-Stories、English CC100 上进行了预训练。有关如何训练这些 pretrained models 的更多信息，请参阅 《Efficient large scale language modeling with mixtures of experts》。

     为了评估 Int8 quantization 后语言建模的 degradation ，我们在 C4 语料库的验证数据上评估 8-bit transformer 的困惑度。C4 语料库是 Common Crawl 语料库的一个子集。我们使用 NVIDIA A40 GPU 进行评估。

   • 另外，我们在 OPT 模型上评估 zero-shot accuracy degradation ，跨不同的下游任务，其中我们将我们的方法与 16-bit baseline 进行比较。

     为了测量 zero-shot 性能的 degradation，我们使用 OPT 模型，并在 EleutherAI 语言模型评估工具箱上对这些模型进行评估。

3.2.4 主要结果

1. 在 C4 语料上对 125M 到 13B 的 Int8 模型的语言建模困惑度的主要结果见 Table 1 。我们看到：

   • 随着模型规模的增加，absmax 、row-wise 和 zeropoint 等等量化都失败了，2.7B 参数后的模型性能低于较小的模型。zeropoint 量化在超过 6.7B 参数后失败。

     在 13B 规模，所有 baseline 方法的效果不如 6.7B 规模的模型。

   • 我们的方法 LLM.int8() 是唯一保持困惑度的方法。因此，LLM.int8() 是唯一具有良好缩放趋势的方法。

   row-wise ：即 block-wise 量化，将张量拆分为多个 block，每个 block 拥有一个量化常数。

   倒数第三行（Int8 absmax row-wise + decomposition ）和 Absmax LLM.int8()(vector-wise + decomp) 的区别仅仅是：前者采用 row-wise、后者采用 vector-wise 。

   最后两行的区别在于：前者采用 Absmax、后者采用 Zeropoint。可以看到，Zeropoint 相对于 absmax 的优势（第二行和第三行）消失了。原因见作者后面的讨论。

   

2. 当我们在 Figure 1 中查看 OPT 模型在 EleutherAI 语言模型评估工具箱上的 zero-shot 性能的缩放趋势时，我们看到：

   • LLM.int8() 随着规模从 125M 到 175B 参数的增加保持了 full 16-bit 性能。

   • 另一方面，基线 8-bit absmax vector-wise quantization 随着规模的增加表现糟糕，衰退为随机性能。

   

3. 虽然我们的主要关注点是节省内存，但我们也测量了 LLM.int8() 的运行时间。

   • 与 FP16 基准相比，quantization 开销可以拖慢小于 6.7B 参数模型的推理速度。但是，6.7B 参数或更小的模型在大多数 GPU 上可以正常适配，实际中不太需要量化。

   • 对于等效于 175B 模型的大矩阵乘法，LLM.int8() 的运行时间约快两倍。

   附录 D 提供了这些实验的更多详细信息。

3.3 大型 transformer 中的离群的大幅值特征

1. 随着 transformer 规模的增加，大幅值的异常值特征涌现（emerge ）并强烈影响所有层及其量化。给定隐状态 $\mathbf{X}\in {\mathbb{R}}^{S\times h}$$\mathbf X\in \mathbb R^{S\times h}$，其中 $S$$S$ 是sequence/token dimension 、$h$$h$ 是 hidden/feature dimension 。我们将特征定义为特定的 hidden/feature dimension $h_i$$h_i$ （即，特征是按列来定义的），$1\le h_i\le h$$1\le h_i\le h$。我们的分析检查给定 transformer 中所有层的特定feature dimensions $h_i$$h_i$ 。

   我们发现：异常值特征对注意力和 transformer 的整体预测性能有很强的影响。 13B 模型中，每个 2048 token sequence 中存在多达 150k 个异常值，但这些异常值特征非常系统化，仅覆盖不超过 7 个 unique feature dimensions $h_i$$h_i$ 。这项分析的见解对开发混合精度分解至关重要。我们的分析解释了 zeropoint quantization 的优势、以及为何在使用混合精度分解后这些优势消失，以及小型模型 vs. 大型模型的量化性能。

3.3.1 寻找异常值特征

1. 定量分析涌现现象（emergent phenomena ）的困难有两个方面。我们旨在选择少量特征进行分析，使结果可理解且不太复杂，同时捕获重要的概率模式和结构模式。我们使用一种经验方法来找到这些约束。我们根据以下标准定义异常值：特征的幅值至少为 6.0 、异常值影响至少 25% 的层、异常值影响至少 6% 的 sequence dimensions （即，6% 的行）。

   更正式地，给定具有 $L$$L$ 层的 transformer 和隐状态 ${\mathbf{X}}_l\in {\mathbb{R}}^{S\times h}$$\mathbf X_l\in \mathbb R^{S\times h}$，$l=1,\cdots ,L$$l=1,\cdots,L$，其中 $S$$S$ 是sequence dimensions 、$h$$h$ 是 feature dimensions ，我们将特征定义为隐状态中的特定维度 $h_i$$h_i$ ，$1\le h_i\le h$$1\le h_i\le h$。我们跟踪那些至少有一个值的绝对值大于 6 的维度 $h_i$$h_i$ ，同时我们仅统计这样的异常值：在所有隐状态中，异常值在至少在同一个特征的 25% 的层中出现，以及至少在 6% 的行中出现。由于特征异常值仅发生在注意力投影（key/query/value/outpu ）和前馈网络扩张层（first sub-layer ）中，因此我们忽略注意力函数和 FFN 收缩层（second sub-layer ）进行此分析。

   我们选择这些阈值的原因如下：

   • 我们发现，使用混合精度分解，如果我们将任何绝对值大于或等于 6 的特征作为异常值特征对待，perplexity degradation 就会停止。

   • 对于异常值影响的层数，我们发现大型模型中的异常值特征是系统性的：要么发生在大多数层、要么根本不出现。

     另一方面，在小型模型中，异常值特征是概率性的：对于每个序列，它们有时出现在某些层中。

     因此，我们设置检测异常值特征的阈值，使得仅在我们最小的 125M 参数模型中检测到单个异常值。这个阈值对应于至少 25% 的transformer 层数受同一feature dimensions的一个异常值的影响。第二常见的异常值仅出现在单个层中（2% 的层），这表明这是一个合理的阈值。

     第二常见的异常值是什么意思？读者猜测是第二大的异常值。

   • 我们使用相同的过程找到异常值特征影响我们 125M 模型中多少行：异常值至少影响 6% 的行（即，sequence dimensions）。

2. 我们测试了高达 13B 参数的模型。为了确保观察到的现象不是软件错误造成的，我们评估了在三个不同软件框架中训练的transformer 。我们评估了使用 OpenAI 软件的四个 GPT-2 模型、使用 Fairseq 软件的五个Meta AI 模型、以及使用 Tensorflow-Mesh 的一个 EleutherAI 模型GPT-J 。更多细节请参见附录 C 。我们还在两个不同的推理软件框架 Fairseq 和Hugging Face Transformers 中执行我们的分析。

   从下表可以看到：

   • C4 validation perplexity 越低，出现的异常值越多。

   • 异常值通常是单侧的，它们的四分位数范围显示，异常值的幅值比其他feature dimensions的最大幅值大 3 ~ 20 倍，而其他feature dimensions的范围通常为 [-3.5, 3.5] 。

   • 随着规模的增加，异常值在 transformer 的所有层中变得越来越常见，并且它们几乎出现在所有的 sequence dimensions中。

   • 在 6.7B 参数时发生了一个相变（phase shift ），对于约 75% 的所有sequence dimensions（SDim ），同一异常值出现在同一feature dimensions的所有层中。尽管只占所有特征的约 0.1% ，但这些异常值对大的 softmax 概率至关重要。

     如果删除异常值，平均 top-1 softmax 概率会缩小约 20% 。因为异常值在 sequence dimensions $S$$S$ 上具有非对称分布，这些异常维度破坏了对称的 absmax 量化，并有利于非对称的 zeropoint 量化。这解释了我们验证困惑度分析中的结果。

   这些观察结果似乎是普遍的，因为它们出现在不同软件框架中训练的模型中（fairseq、OpenAI、Tensorflow-mesh ），并且它们出现在不同的推理框架中（fairseq、Hugging Face Transformers）。这些异常值似乎也对 transformer 架构的细微变化稳健（rotary embeddings 、embedding norm 、residual scaling 、不同初始化）。

   

3.3.2 测量异常值特征的影响

1. 为了证明异常值特征对注意力和预测性能至关重要，我们在将隐状态 ${\mathbf{X}}_l$$\mathbf X_l$ 馈入注意力层投影层之前将异常值特征设为零，然后将 top-1 softmax 概率与常规的包含异常值的 softmax 概率进行比较。我们对所有层独立地执行此操作，这意味着我们 forward 常规的 softmax 概率值从而避免 cascading errors 并隔离由异常值特征引起的效应。如果我们删除outlier feature dimension（即，将其设为零）并通过 transformer 传播这些被改变的隐状态，我们还报告 perplexity degradation 。作为对照，我们对随机的 non-outlier feature dimensions 应用相同的程序，并注意 attention and perplexity degradation 。

   我们的主要定量结果可以总结为四个要点：

   • (1) ：当以参数数量衡量时，大幅值特征在 transformer 所有层之间的涌现，在 Figure 3a 所示，在 6B 至 6.7B 参数之间突然发生，受影响的层百分比从 65% 增至 100% 。受影响的 sequence dimensions数量迅速从 35% 增加到 75% 。这种突然的 shift 与量化开始失败的时机同时发生。

   • (2)：另一方面，当以困惑度衡量时，大幅值特征在 transformer 所有层之间的涌现，可以看做是根据 decreasing perplexity 的指数函数平滑出现，如 Figure 3b 所示。这表明涌现没有什么突然，通过在更小的模型中研究指数趋势，我们可能能在发生相变之前检测到离群特征（emergent features ）。这也表明涌现不仅与模型大小有关，还与许多其他因素有关，例如所使用的训练数据量和数据质量（《Training compute-optimal large language models》、《Scaling laws for autoregressive generative modeling》）。

   • (3)：一旦异常值特征出现在 transformer 的所有层中，median outlier feature magnitude 就迅速增加，如 Figure 4a 所示。异常值特征的大幅值和不对称分布扰乱了 Int8 量化精度。这是 6.7B 规模开始量化方法失败的核心原因：量化分布（quantization distribution ）的范围太大，以至于大多数 quantization bins 是空的，small quantization values 被量化为零，本质上销毁了信息。我们假设，除了 Int8 推理之外，常规的 16-bit 浮点训练在超过 6.7B 规模后也会不稳定（如果向量相乘，而向量被填充了 magnitude 为 60 的值，很容易偶然超过最大的 16-bit 值 65535 ）。

   • (4)：如 Figure 4b 所示，随着 C4 perplexity 的降低，异常值特征的数量严格单调增加，而与模型大小的关系是非单调的。这表明模型困惑度而不是模型大小确定了相变。我们假设模型大小只是达到涌现所需的许多协变量中的一个重要协变量。

   相变发生后，这些异常值特征高度系统化。例如，对于一个序列长度为 2048 的 6.7B 参数 transformer ，我们发现对于整个transformer ，每个 sequence 约有 150k 个异常值特征，但这些特征仅集中在 6 个不同的 hidden dimensions 中。

   这些异常值对 transformer 性能至关重要。如果删除异常值，平均 top-1 softmax 概率从约 40% 降低到约 20% ，验证困惑度增加600-1000% ，即使最多只有 7 个 outlier feature dimensions 。而当我们删除 7 个随机的feature dimensions时，top-1 softmax 概率仅降低 0.02-0.3% ，困惑度增加 0.1% 。这突显了这些feature dimensions的关键性质。这些异常值特征的量化精度至关重要，因为即使轻微的错误也会对模型性能产生巨大影响。

   

   

3.3.3 量化性能的解释

1. 我们的分析表明，特定feature dimensions的异常值在大型 transformer 中无处不在，这些feature dimensions对 transformer 性能至关重要。由于 row-wise and vector-wise quantization 对每个 hidden state sequence dimension $S$$S$ （行）进行缩放，而异常值发生在 feature dimension $h$$h$ （列）中，所以两种方法都无法有效处理这些异常值。这就是为什么 absmax 量化方法在 emergence 后迅速失败的原因。

   但是，几乎所有异常值都有严格的非对称分布：它们要么仅为正，要么仅为负（参见附录 C ）。这使得 zeropoint 量化对这些异常值特别有效，因为 zeropoint 量化是一种非对称量化方法，可以将这些异常值缩放到完整范围 [-127, 127] 中。这解释了我们的 quantization scaling benchmark（Table 1 ）中 zeropoint 量化的强大性能。但是，在 13B 参数规模，即使是 zeropoint 量化也会由于累积的量化误差和 outlier magnitudes 的快速增长而失败，如图 Figure 4a 所示。

   如果我们使用完整的 LLM.int8() 方法及混合精度分解， zeropoint 量化的优势消失，这表明 remaining decomposed features 是对称的。但是，与 row-wise quantization 相比，vector-wise 仍具有优势，这表明增强模型权重的量化精度对保持完整的预测性能至关重要。

3.4 讨论和局限性

1. 我们首次证明，十亿参数级的 transformer 可以量化为 Int8 并立即用于推理，而不降低性能。我们通过使用我们在大规模分析出现的大幅值特征获得的见解来开发混合精度分解，从而将异常值特征隔离在单独的 16-bit 矩阵乘法中。结合我们的 vector-wise quantization 方法，我们经验证明可以恢复高达 175B 参数模型的完整推理性能。

2. 局限性：

   • 我们工作的主要局限性是：我们的分析仅针对 Int8 数据类型，未研究 8-bit 浮点（FP8 ）数据类型。由于当前 GPU 和 TPU 不支持此数据类型，我们认为这最好留待未来工作。但是，我们也认为 Int8 数据类型的许多见解将直接转换为 FP8 数据类型。

   • 另一个局限性是：我们只研究了高达 175B 参数的模型。虽然我们将 175B 模型量化为 Int8 而不降低性能，但在更大规模上，额外的 emergent properties 可能会破坏我们的量化方法。

   • 第三个局限性是：我们没有对注意力函数使用 Int8 乘法。由于我们的重点是减少内存占用，而注意力函数不使用任何参数，所以这并不是绝对必要的。然而，对这个问题的初步探索表明，需要除了这里开发的之外的其他量化方法，我们留待未来工作。

   • 最后一个局限性是：我们关注推理但不研究训练或微调。我们在附录 E 中对大规模 Int8 微调和训练进行了初步分析。大规模Int8 训练需要在量化精度、训练速度、以及工程复杂性之间进行复杂的 trade-off ，这是一个非常困难的问题。我们同样留待未来工作。

3. 更广泛的影响：我们工作的主要影响是，使以前因 GPU 内存有限而无法适配的大型模型变得可访问。这使得以前由于 GPU 内存有限而无法进行的研究和应用成为可能，特别是对资源最少的研究人员。 Table 2 列出了现在可以在不降低性能的情况下访问的 model/GPU 组合。但是，我们的工作也使得拥有许多 GPU 的资源丰富的组织可以在相同数量的 GPU 上 serve 更多模型，这可能会增加资源丰富和资源贫穷组织之间的差距。

   具体而言，我们认为公开发布大型 pretrained 模型（例如最近的 Open Pretrained Transformers: OPT ）以及我们对 zero-shot and few-shot prompting 的新的 Int8 推理，将为以前由于资源约束而无法进行的学术机构启用新的研究。这种大型模型的广泛可访问性可能对社会产生难以预测的有益的和有害的影响。

   

四、ZeroQuant [2022]

论文：《ZeroQuant: Efficient and Affordable Post-Training Quantization for Large-Scale Transformers》

1. 大型自然语言模型已经在不同的应用中被广泛采用，例如使用 BERT 进行自然语言理解，以及使用 GPT-style 模型进行生成任务。虽然这些模型已经取得了 SOTA 的准确性，但随着模型规模的剧增，部署它们所需的内存占用和计算成本已经成为一个主要的瓶颈，即使是在强大的 GPU 云服务器上也是如此。

   量化是缓解这一挑战的一个有前景的方法，它可以降低权重和 activations 的 bit precision ，以达到更小的内存占用、以及更快的计算（例如 T4/A100 上的 INT8 Tensor cores ）。然而，量化通常需要重新训练（也称为 quantization aware training: QAT ）来恢复由 weight and activations 的 representation loss 导致的准确率下降。为启用 QAT ，通常需要完整的训练流程（包括训练数据和计算资源），从而微调模型。现在访问这些组件的机会往往是没有的，而 QAT 也是一个非常耗时的过程，特别是对于那些大型模型。

   最近，zero-shot quantization （《Zeroq: A novel zero shot quantization framework》、《Data-free quantization through weight equalization and bias correction》）和 post-training quantization: PTQ （《Up or down? adaptive rounding for post-training quantization》、《Post-training quantization for vision transformer》）被提出，从而解决训练数据访问和计算需求的挑战，因为 PTQ 通常不需要（或只需要很少的）重新训练。但是大多数这些工作主要关注相对较小规模的计算机视觉问题。更近期，《Understanding and overcoming the challenges of efficient transformer quantization》 在 BERT 上展示了有前景的 PTQ 结果。然而：

   • (1) ：它的主要关注点是 BERT_base 上的高精度量化（INT8/FP16 ）。

   • (2) ：它没有考虑其他规模达十亿级别的参数的生成式模型（GPT-3-style 模型）。

   更重要的是，大多数这些工作没有报告真实的延迟改进，这就质疑了这些方法在改进inference latency 方面的有用性。例如，现有的工作通常不讨论与不同量化方案相关的 quantization/dequantization 成本，而这实际上对使用低精度带来的性能收益有很大影响。

   此外，对于极端量化（例如 INT4 ），通常使用知识蒸馏来提高性能，与 QAT 相比这又增加了昂贵的计算成本。而且，为了取得更好的准确率性能，通常对 quantized model 应用 hidden-states knowledge distillation ，例如 《Binarybert: Pushing the limit of bert quantization》、《Ternarybert: Distillation-aware ultra-low bit bert》。这会给 GPU 内存和计算资源需求带来巨大压力，因为 teacher 模型和 student 模型都需要加载到 GPU 内存中进行训练。

   在本文中，我们提出 ZeroQuant ，一个端到端的 post-training quantization and inference pipeline ，以解决这些挑战，目标是 INT8 和 INT4/INT8 混合精度量化。具体来说，我们的贡献如下：

   • 我们对权重和 activations 应用细粒度的硬件友好的量化方案，即权重的 group-wise quantization （即，列维度）、以及 activations 的 token-wise quantization （即，行维度）。这两种量化方案都可以显著减少量化误差并保留 hardware acceleration 特性。

   • 我们提出了一种新的 layer-by-layer knowledge distillation: LKD 用于 INT4/INT8 混合精度量化，其中神经网络通过最小迭代的知识蒸馏被 layer-by-layer 地量化，甚至不需要访问原始训练数据。因此，在任意时刻，设备内存主要仅加载单个额外 layer 的占用，这使得规模达十亿级参数的模型蒸馏在有限的训练预算和 GPU 设备下成为可能。

   • 我们开发了一个高度优化的推理后端（inference backend ），消除了 quantization/dequantization 算子的高昂计算成本，在现代 GPU 硬件的 INT8 Tensor cores 上实现了延迟加速。

   • 我们的经验结果显示：

     • ZeroQuant 可以将 BERT 和 GPT-3-style 模型量化为 INT8 权重和 activations 从而保留准确性，而不会产生任何重新训练成本。与 FP16 推理相比，在 A100 GPU 上，我们的 INT8 模型在 BERT_base/GPT-3_350M 上获得了高达 5.19x/4.16x 的加速。

     • ZeroQuant puls LKD 可以进行 BERT 和 GPT-3-style 模型的 INT4/INT8 混合精度量化。与 FP16 模型相比，这导致了 3 倍的内存减少，准确率损失可以忽略。而且，得益于 LKD 的轻量级，我们可以在 33 秒（BERT_base ）和 10 分钟（BERT_large ）内完成量化过程。我们还展示 LKD 可以使用其他数据集达到类似于原始训练数据的性能。

     • 我们展示了 ZeroQuant 在两个最大的开源语言模型 GPT-J_6B 和 GPT-NeoX_20B 上的可扩展性，使用 INT8 量化。ZeroQuant 可以在 GPT-J_6B 上实现比 FP16 模型快 3.67 倍；并且 ZeroQuant 将 GPT-NeoX_20B 的 GPU 需求从 2 减少到 1 ，延迟从 65ms 降低到 25ms （整体系统效率提高 5.2 倍）。

   本文的主要贡献是两个：layer-by-layer knowledge distillation 、以及高度优化的推理后端。

2. 相关工作：人们从不同方面探索了模型压缩。其中，量化是最有前景的方向之一，因为它可以直接减少内存占用和计算强度。这里我们聚焦 NLP 模型的量化，并简要讨论相关工作。

   • 大多数量化工作可以归类为 quantization-aware training: QAT 。

     • 《Q-BERT: Hessian based ultra low precision quantization of bert》 和 《Q8BERT: Quantized 8bit bert》 是第一批使用整数对权重和 activations 进行 BERT 模型量化的工作。具体而言，《Q-BERT: Hessian based ultra low precision quantization of bert》 利用 Hessian 信息将权重 bit-precision 推到 INT2/INT4 ，它还提出了 group-wise quantization ，从而比 single matrix quantization 更细粒度的方式对权重矩阵进行量化。

     • 《Training with quantization noise for extreme fixed-point compression》 引入 quantization noise 以缓解 QAT 的方差。

     • 《Ternarybert: Distillation-aware ultra-low bit bert》、《Binarybert: Pushing the limit of bert quantization》 利用非常昂贵的知识蒸馏 （《Distilling the knowledge in a neural network》）和数据增强 （《Tinybert: Distilling bert for natural language understanding》 ）从而 ternarize/binarize 权重。

     • 《Kdlsq-bert: A quantized bert combining knowledge distillation with learned step size quantization》 结合知识蒸馏和 learned step size quantization （《Learned step size quantization》）将权重量化到 2-8 bits 。

     • 最近，《Compression of generative pre-trained language models via quantization》 也使用知识蒸馏将 GPT-2 模型在特定任务上压缩到 INT2 。

     所有这些工作都是使用原始训练数据集对模型进行量化的。更重要的是，它们需要重新训练、或微调整个模型来恢复准确率。这种 extra-large models （比如 megatron-turing nlg 530b, Palm）的计算成本，对大多数研究实验室或从业者来说几乎是不可承受的。

   • 克服计算成本挑战的一种解决方案是 post-training quantization: PTQ 。然而，PTQ 通常会导致显著的准确率下降，因为网络对量化误差敏感。

     • 沿着这条线，Transformer-based 模型的第一批工作之一是 《Gobo: Quantizing attention-based nlp models for low latency and energy efficient inference》 。作者提出了基于质心的量化方法，其中 outlier numbers 使用 FP32 格式，其余 numbers 使用 non-uniform quantization 。因此，很难在 general compute accelerators （如 CPU 和 GPU ）上获得真实的inference latency 收益，因为这些硬件中的 parallel processing units 不支持混合数据类型的有效计算。

     • 更近期地，《Understanding and overcoming the challenges of efficient transformer quantization》 为模型的一部分引入了高精度的 activation quantization （FP16 ）以克服 high dynamic activation ranges 。

     但是，据我们所知：

     • (1) ： 在先前的工作中还没有研究如何在GPT-3-style 模型上应用 PTQ 而达到高准确率。

     • (2)：如何在十亿级规模的模型上应用 PTQ 仍较少被探索。

     • (3)：高效的推理系统后端（inference system backend ）仍然缺失，尤其是对于细粒度量化方案，这使得很难在通用硬件上获得低延迟。

     ZeroQuant 通过考虑 system backend 融入算法设计来解决所有这些局限性。我们在 BERT 和大型 GPT-3-style 模型（高达 20B 参数，即 GPT-NeoX_20B ）上验证了ZeroQuant 的能力，用于各种任务。

4.1 背景和挑战

1. 我们在附录 A 中简要概述了 Transformer 架构和量化背景。请参阅 《Attention is all you need》 和 《A survey of quantization methods for efficient neural network inference》 以了解更多关于 Transformer 架构和量化的细节。

2. 与 QAT 相比，PTQ 展现了更大的压缩效率，因为 PTQ 通常被用于 quantize the model 而无需重新训练。PTQ 的一种常见策略是将训练数据馈入网络，并使用 running mean 来校准 scaling factor $S$$S$ 。更多细节请参见附录 B.1 。

   一些工作已经在 BERT_base 模型上完成，使用 INT8 权重和混合 INT8/FP16 的 activation 量化。然而，还没有针对：

   • (1) ：BERT 模型上的更 bit-precision 的 PTQ 进行研究。

   • (2) ： 大型 GPT-3-style 模型进行研究。

   这里，我们简要讨论在 BERT （见附录 C ）和 GPT-3-style 模型上应用 PTQ 的挑战。

   Table 1 显示了带 PTQ 的 GPT-3_350M 的结果。可以看出：

   • INT8 activation quantization （即 W16A8 的行）引起了主要的 accuracy loss 。

   • 进一步将权重推到 INT8 （即 W8A8 的行）不改变 zero-shot 评估任务的准确率，但导致因果语言建模任务（Wikitext-2 ）的困惑度得分变差；这表明与其他 zero-shot 问题相比，生成式任务的敏感性。

   • 对于 W4/8A16 ，在一些 accuracy-based 的任务上，GPT-3350M 仍然达到了合理的性能，如 OpenBookQA ；但它在大多数其余任务上损失了准确率。特别是对于 Wikitext-2 ，具有 W4/8A16 的 GPT-3_350M 无法再生成任何有意义的文本。

   BERT 的分析请参见附录 C 。

   WaAb 表示：对权重采用 a-bit、对 activation 采用 b-bit 。

   W4/8A16 表示：对权重混合采用 4-bit 和 8-bit 、对 activation 采用 16-bit 。其中，将自注意力计算的权重量化为 INT8 、feed-forward connection: FFC 的权重量化为 INT4 。

   W8A8/16 表示：对权重采用 8-bit、对 activation 混合采用 8-bit 和 16-bit 。其中，将自注意力计算的 input activation 使用 FP16 activation ，对其余计算使用 INT8 。

   

3. Dynamic Activation Range：为了研究为什么 INT8 activation 对 BERT 和 GPT-3-style 模型都导致显著的准确率下降，我们在 Figure 1(left) 中绘制了 GPT-3_350M 不同 Transformer layers 的每个 activation 的 token-wise （即，行维度）的 range 。可以看出，不同 token 具有极大的 activation ranges 差异。例如，最后一层的 maximum range 约为 35、而 minimum range 接近 8 。这种 activation range 的较大方差使得使用固定的 quantization range （通常是最大值）对所有token 进行量化以保持预测准确率变得困难，因为对于 small range tokens 的 limited representation 能力会损害准确率性能。

   

4. Different Ranges of Neurons in Weight Matrices：类似地，我们在 Figure 1(right) 中绘制了 GPT-3_350M 的 attention output matrix （即，${\mathbf{W}}_o$$\mathbf W_o$ ）的逐行（即 output dimension) ）的 weight range 。不同行之间的 largest magnitudes 存在 10 倍的差异，这导致 INT8 weight PTQ 的 generation 性能变差。当应用 INT4 量化时，这也提出了很大的挑战，因为 INT4 只有 16 个数字，更小 10 倍的范围导致这些 smaller-range rows 的 representations 只有 2 或 3 个数字。

5. 这些分析结果也表明了为什么需要更昂贵的 hidden-states knowledge distillation 来进行 ultra-low precision quantization 以弥合准确率差距。但是，由于大型模型的训练成本太高，因此需要一个轻量级的和高效的方法进行 PTQ 。

4.2 方法

4.2.1 细粒度的硬件友好的量化方案

1. 如前所述，即使对 BERT/GPT-3-style 模型应用 INT8 PTQ 也会导致显著的准确率下降。关键挑战是 INT8 的 representation 并不能完全捕获权重矩阵中不同行的、以及不同 activation tokens 的数值范围。一种解决方法是对权重矩阵（或 activations ）采用 group-wise (token-wise) quantization 。

2. Group-wise Quantization for Weights： group-wise weight matrix quantization 首先在 《Q-BERT: Hessian based ultra low precision quantization of bert》 中被提出，其中权重矩阵 $\mathbf{W}\in {\mathbb{R}}^{n\times m}$$\mathbf W\in \mathbb R^{n\times m}$ 被划分为 $g$$g$ 个组，每个组分别被量化。然而，在 《Q-BERT: Hessian based ultra low precision quantization of bert》 中，作者仅将此应用于 quantization aware training 。更重要的是，他们没有考虑硬件效率约束（hardware efficiency constraint ），也没有系统后端支持。因此，他们缺乏真实的 latency reduction 效益。

   在我们的设计中，我们考虑了 Ampere Architecture 的 GPU （例如 A100 ）的硬件约束，其中计算单元基于 Warp Matrix Multiply and Accumulate (WMMA) tiling size （《Using tensor cores in cuda fortran》）从而实现最佳加速。接下来，我们将展示，与 single-matrix quantization 相比，我们的 group-wise quantization 由于更细粒度的量化而具有更好的准确率，同时仍然实现了很大的 latency reduction 。

   group-wise weight matrix quantization 是怎么实现的？读者猜测是对权重矩阵按照 $g$$g$ 列一个 block 来进行量化。

   $g$$g$ 选择什么样的值？论文并未说清楚。

3. Token-wise Quantization for Activations：如前面内容和附录 A.2 所述，现有 PTQ 工作的一种常见做法是：对 activation 使用静态量化，其中 min/max range 在离线校准阶段（offline calibration phase ）计算。这种方法对于 activation range 方差较小的小型模型可能就足够了。然而，正如前面分析的那样，对于 GPT-3_350M 和 BERT_base 等大型 Transformer 模型，activation range 存在巨大的方差。因此，静态量化方案（通常应用于所有 tokens/samples ）会导致显著的准确率下降。克服这个问题的一个自然想法是：采用更细粒度的 token-wise quantization ，并为每个 token 动态地计算 min/max range 以减少来自 activations 的量化误差。我们在实验部分的评估也显示了 token-wise quantization 对 GPT-3-style 和 BERT 模型的准确率有显著改善。

   token-wise quantization 是怎么实现的？读者猜测：是对 activation 矩阵按行进行量化。

   然而，直接在现有的深度学习框架（如 PyTorch quantization suite ）中应用 token-wise quantization 会导致显著的 quantization and dequantization 成本，因为token-wise quantization 引入了额外的操作，这些操作导致 GPU 计算单元和主内存（main memory）之间的昂贵的数据移动开销。为解决此问题，我们为 transformer 模型的 token-wise quantization 构建了一个高度优化的推理后端（inference backend）。例如，ZeroQuant 的推理后端采用所谓的 kernel fusion 技术，将 quantization operator 与其前面的算子（如 layer normalization ）融合，以减轻 token-wise quantization 带来的数据移动成本。类似地，不同 GeMM's output 的逆量化成本，通过如下方式缓解：在将 final FP16 result 写回主内存以供下一个 FP16 算子（如 GeLU ）使用之前，使用 weight and activation quantization scales 对 INT32 accumulation 进行缩放。这些优化将在接下来详细讨论。

   token-wise quantization 可以显著减少 quantized activations 的 representation error 。而且，由于它不需要校准 activation range，接下来我们将展示对于中等量化方案（ INT8 weight with INT8 activation ），ZeroQuant 不会产生任何与量化相关的成本（例如 activation range calibration ）。

   注意，论文实验部分提到，对于大型模型（如 GPT-NeoX_20B ），需要将自注意力的 input activation 保持为 FP16 。如果将自注意力的 input activation 量化为 INT8 甚至 INT4，则会带来 accuracy loss 。

4.2.2 Layer-by-layer Knowledge Distillation with Affordable Cost

1. 知识蒸馏（knowledge distillation: KD ）是减轻模型压缩后准确率下降的最强大方法之一。然而，KD 存在几个局限性，特别是在大型语言模型上的 hidden-states KD ：

   • (1)：KD 需要在训练期间同时持有 teacher 模型和 student 模型，这大大增加了内存和计算成本。

   • (2)：KD 通常需要 full training 学生模型。因此，需要在内存中存储权重参数的若干副本（梯度、一阶动量、二阶动量等）以更新模型。

   • (3)：KD 通常需要原始训练数据，而由于隐私/保密问题，有时无法访问这些数据。

   为解决这些局限性，我们提出了 layer-by-layer distillation: LKD 算法。假设要量化的目标模型有 $N$$N$ 个 transformer blocks ，$L_1,\cdots ,L_N$$L_1,\cdots,L_N$ ，可访问的数据集有输入 $(\mathbf{X},\mathbf{Y})$$(\mathbf X, \mathbf Y)$，可以是原始训练数据，也可以是来自其他数据源的数据集、甚至是随机生成的数据。我们的 LKD 逐层地对网络进行量化，并使用其原始版本（即 unquantized 版本）作为 teacher 模型。

   具体而言，假设层 $L_k$$L_k$ 将要被量化，其 quantized 版本是 ${\hat{L}}_k$$\hat L_k$ 。然后，我们使用 $L_{k-1}$$L_{k-1}$ 的输出（即在 first k-1 layers 上对 $\mathbf{X}$$\mathbf X$ 进行推理）分别作为 $L_k$$L_k$ 和 ${\hat{L}}_k$$\hat L_k$ 的输入，测量 $L_k$$L_k$ 和 ${\hat{L}}_k$$\hat L_k$ 输出之间的差异，并对 ${\hat{L}}_k$$\hat L_k$ 进行模型更新，即：

   $$\begin{array}{}\text{(29)}& {\mathcal{L}}_{\text{LKD},k}=\text{MSE}(L_k(L_{k-1}(\cdots L_1(\mathbf{X}))),{\hat{L}}_k(L_{k-1}(\cdots L_1(\mathbf{X}))))\end{array}$$

   其中： MSE 是均方误差，也可以替换为其他损失函数（例如 KL 散度）。

   可以看出：

   • (1) ：我们的 LKD 不需要单独的 teacher 模型，因为我们对 teacher/student 模型都使用相同的 $L_1$$L_1$ 到 $L_{k-1}$$L_{k-1}$ 。因此，我们的额外模型成本只有 $L_k$$L_k$。

     每次仅仅调整 quantized 版本的一层，因此是一种贪心算法。

   • (2) ：optimizer states 的内存开销显著减少，因为唯一优化的层是 $L_k$$L_k$ 。

   • (3)：由于我们从不优化 end-to-end model ，训练不再依赖标签。后面我们将在实验章节中展示 LKD 不依赖于原始训练数据。

     论文的实验部分展示：即使采用随机生成的 token ids ，LKD 也能够提升模型的性能。

     从实验部分可以看到：LKD 对于生成式任务的提升，相比分类任务，要更大。