Megengine量化
Megengine量化
量化指的是将浮点数模型（一般是32位浮点数）的权重或激活值用位数更少的数值类型（比如8位整数、16位浮点数）来近似表示的过程。 量化后的模型会占用更小的存储空间，还能够利用许多硬件平台上的专属算子进行提速。比如在 MegEngine 中使用8位整数来进行量化，相比默认的32位浮点数，模型大小可以减少为1/4，而运行在特定的设备上其计算速度也能提升为2-4倍。
量化的目的是为了追求极致的推理计算速度，为此舍弃了数值表示的精度，直觉上会带来较大的模型掉点，但是在使用一系列精细的量化处理之后，其掉点可以变得微乎其微，并能支持正常的部署使用。而且近年来随着专用神经网络加速芯片的兴起，低比特非浮点的运算方式越来越普及，因此如何把一个 GPU 上训练的浮点数模型转化为低比特的量化模型，就成为了工业界非常关心的话题。
一般来说，得到量化模型的转换过程按代价从低到高可以分为以下4种：
图1. 量化转换过程分类
- Type1 和 Type2 由于是在模型浮点模型训练之后介入，无需大量训练数据，故而转换代价更低，被称为后量化（Post Quantization）；
- Type3 和 Type4 则需要在浮点模型训练时就插入一些假量化（FakeQuantize）算子，模拟计算过程中数值截断后精度降低的情形，故而称为量化感知训练（Quantization Aware Training, QAT）。
本文主要介绍 Type2 和 Type3 在 MegEngine 中的完整流程，事实上，除了 Type2 无需进行假量化，两者的整体流程完全一致。
整体流程
以 Type3 为例，一般以一个训练完毕的浮点模型为起点，称为 Float 模型。包含假量化算子的用浮点操作来模拟量化过程的新模型，称为 Quantized-Float 模型，或者 QFloat 模型。可以直接在终端设备上运行的模型，称为 Quantized 模型，简称 Q 模型。
而三者的精度一般是 Float > QFloat > Q ，故而一般量化算法也就分为两步：
- 拉近 QFloat 和 Q，这样训练阶段的精度可以作为最终 Q 精度的代理指标，这一阶段偏工程；
- 拔高 QFloat 逼近 Float，这样就可以将量化模型性能尽可能恢复到 Float 的精度，这一阶段偏算法。
典型的三种模型在三个阶段的精度变化如下：
图2. 三阶段模型的精度变化
对应到具体的 MegEngine 接口中，三阶段如下：
- 基于 Module 搭建网络模型，并按照正常的浮点模型方式进行训练；
- 使用 quantize_qat() 将浮点模型转换为 QFloat 模型，其中可被量化的关键 Module 会被转换为 QATModule ，并基于量化配置 QConfig 设置好假量化算子和数值统计方式；
- 使用 quantize() 将 QFloat 模型转换为 Q 模型，对应的 QATModule 则会被转换为 QuantizedModule ，此时网络无法再进行训练，网络中的算子都会转换为低比特计算方式，即可用于部署了。
该流程是 Type3 对应 QAT 的步骤，Type2 对应的后量化则需使用不同 QConfig，且需使用 evaluation 模式运行 QFloat 模型，而非训练模式。更多细节可以继续阅读下一节详细的接口介绍。
接口介绍
在 MegEngine 中，最上层的接口是配置如何量化的 QConfig 和模型转换模块里的 quantize_qat() 与 quantize() 。
QConfig
QConfig 包括了 Observer 和 FakeQuantize 两部分。知道，对模型转换为低比特量化模型一般分为两步：一是统计待量化模型中参数和 activation 的数值范围（scale）和零点（zero_point），二是根据 scale 和 zero_point 将模型转换成指定的数值类型。而为了统计这两个值，需要使用 Observer。
Observer 继承自 Module ，也会参与网络的前向传播，但是其 forward 的返回值就是输入，所以不会影响网络的反向梯度传播。其作用就是在前向时拿到输入的值，并统计其数值范围，并通过 get_qparams() 来获取。所以在搭建网络时把需要统计数值范围的的 Tensor 作为 Observer 的输入即可。
# forward of MinMaxObserver
def forward(self, x_orig):
if self.enabled:
# stop gradient
x = x_orig.detach()
# find max and min
self.min_val._reset(F.minimum(self.min_val, x.min()))
self.max_val._reset(F.maximum(self.max_val, x.max()))
return x_orig
如果只观察而不模拟量化会导致模型掉点，于是需要有 FakeQuantize 来根据 Observer 观察到的数值范围模拟量化时的截断，使得参数在训练时就能提前“适应“这种操作。FakeQuantize 在前向时会根据传入的 scale 和 zero_point 对输入 Tensor 做模拟量化的操作，即先做一遍数值转换再转换后的值还原成原类型，如下所示：
def fake_quant_tensor(inp: Tensor, qmin: int, qmax: int, q_dict: Dict) -> Tensor:
scale = q_dict["scale"]
zero_point = 0
if q_dict["mode"] == QuantMode.ASYMMERTIC:
zero_point = q_dict["zero_point"]
# Quant
oup = Round()(inp / scale) + zero_point
# Clip
oup = F.minimum(F.maximum(oup, qmin), qmax)
# Dequant
oup = (oup - zero_point) * scale
return oup
目前 MegEngine 支持对 weight/activation 两部分的量化，如下所示：
ema_fakequant_qconfig = QConfig(
weight_observer=partial(MinMaxObserver, dtype="qint8", narrow_range=True),
act_observer=partial(ExponentialMovingAverageObserver, dtype="qint8", narrow_range=False),
weight_fake_quant=partial(FakeQuantize, dtype="qint8", narrow_range=True),
act_fake_quant=partial(FakeQuantize, dtype="qint8", narrow_range=False),
)
这里使用了两种 Observer 来统计信息，而 FakeQuantize 使用了默认的算子。
如果是后量化，或者说 Calibration，由于无需进行 FakeQuantize，故而其 fake_quant 属性为 None 即可：
calibration_qconfig = QConfig(
weight_observer=partial(MinMaxObserver, dtype="qint8", narrow_range=True),
act_observer=partial(HistogramObserver, dtype="qint8", narrow_range=False),
weight_fake_quant=None,
act_fake_quant=None,
)
除了使用在 megengine.quantization.qconfig 里提供的预设 QConfig，也可以根据需要灵活选择 Observer 和 FakeQuantize 实现自己的 QConfig。目前提供的 Observer 包括：
- MinMaxObserver ，使用最简单的算法统计 min/max，对见到的每批数据取 min/max 跟当前存的值比较并替换，基于 min/max 得到 scale 和 zero_point；
- ExponentialMovingAverageObserver ，引入动量的概念，对每批数据的 min/max 与现有 min/max 的加权和跟现有值比较；
- HistogramObserver ，更加复杂的基于直方图分布的 min/max 统计算法，且在 forward 时持续更新该分布，并根据该分布计算得到 scale 和 zero_point。
对于 FakeQuantize，目前还提供了 TQT 算子，另外还可以继承 _FakeQuant 基类实现自定义的假量化算子。
在实际使用过程中，可能需要在训练时让 Observer 统计并更新参数，但是在推理时则停止更新。 Observer 和 FakeQuantize 都支持 enable() 和 disable() 功能，且 Observer 会在 train() 和 train() 时自动分别调用 enable/disable。
所以一般在 Calibration 时，会先执行 net.eval() 保证网络的参数不被更新，然后再执行 enable_observer(net) 来手动开启 Observer 的统计修改功能。
模型转换模块与相关基类
QConfig 提供了一系列如何对模型做量化的接口，而要使用这些接口，需要网络的 Module 能够在 forward 时给参数、activation 加上 Observer 和进行 FakeQuantize。转换模块的作用就是将模型中的普通 Module 替换为支持这一系列操作的 QATModule ，并能支持进一步替换成无法训练、专用于部署的 QuantizedModule 。
基于三种基类实现的 Module 是一一对应的关系，通过转换接口可以依次替换为不同实现的同名 Module。同时考虑到量化与算子融合（Fuse）的高度关联，提供了一系列预先融合好的 Module，比如 ConvRelu2d 、 ConvBn2d 和 ConvBnRelu2d 等。除此之外还提供专用于量化的 QuantStub 、 DequantStub 等辅助模块。
转换的原理很简单，就是将父 Module 中可被量化（Quantable）的子 Module 替换为对应的新 Module。但是有一些 Quantable Module 还包含 Quantable 子 Module，比如 ConvBn 就包含一个 Conv2d 和一个 BatchNorm2d，转换过程并不会对这些子 Module 进一步转换，原因是父 Module 被替换之后，其 forward 计算过程已经完全不同了，不会再依赖于这些子 Module。
Note
如果需要使一部分 Module 及其子 Module 保留 Float 状态，不进行转换，可以使用 disable_quantize() 来处理。
如果网络结构中涉及一些二元及以上的 ElementWise 操作符，比如加法乘法等，由于多个输入各自的 scale 并不一致，必须使用量化专用的算子，并指定好输出的 scale。实际使用中只需要把这些操作替换为 Elemwise 即可，比如 self.add_relu = Elemwise("FUSE_ADD_RELU")
由于转换过程修改了原网络结构， 网络的训练和测试 中提到的模型保存与加载无法直接适用于转换后的网络，读取新网络保存的参数时，需要先调用转换接口得到转换后的网络，才能用 load_state_dict 将参数进行加载。
实例讲解
下面以 ResNet18 为例来讲解量化的完整流程，完整代码见 MegEngine Models 。主要分为以下几步：
- 修改网络结构，使用已经 Fuse 好的 ConvBn2d、ConvBnRelu2d、ElementWise 代替原先的 Module；
- 在正常模式下预训练模型，并在每轮迭代保存网络检查点；
- 调用 quantize_qat() 转换模型，并进行 finetune；
- 调用 quantize() 转换为量化模型，并执行 dump 用于后续模型部署。
网络结构见 resnet.py ，相比惯常写法，修改了其中一些子 Module，将原先单独的 conv, bn, relu 替换为 Fuse 过的 Quantable Module。
class BasicBlock(Module):
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv_bn_relu = ConvBnRelu2d(
in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False
)
self.conv_bn = ConvBn2d(
planes, planes, kernel_size=3, stride=1, padding=1, bias=False
)
self.add_relu = Elemwise("FUSE_ADD_RELU")
self.shortcut = Sequential()
if stride != 1 or in_planes != planes:
self.shortcut = Sequential(
ConvBn2d(in_planes, planes, kernel_size=1, stride=stride, bias=False)
)
def forward(self, x):
out = self.conv_bn_relu(x)
out = self.conv_bn(out)
cut = self.shortcut(x)
out = self.add_relu(out, cut)
return out
然后对该模型进行若干轮迭代训练，并保存检查点，这里省略细节：
for step in range(0, total_steps):
# Linear learning rate decay
epoch = step // steps_per_epoch
learning_rate = adjust_learning_rate(step, epoch)
image, label = next(train_queue)
image = tensor(image.astype("float32"))
label = tensor(label.astype("int32"))
n = image.shape[0]
loss, acc1, acc5 = train_func(image, label, net, gm)
optimizer.step()
optimizer.clear_grad()
调用 quantize_qat() 来将网络转换为 QATModule：
from megengine.quantization import ema_fakequant_qconfig
from megengine.quantization.quantize import quantize_qat
model = ResNet18()
if args.mode != "normal":
quantize_qat(model, ema_fakequant_qconfig)
使用默认的 ema_fakequant_qconfig 来进行 int8 量化。
然后继续使用上面相同的代码进行 finetune 训练。值得注意的是，如果这两步全在一次程序运行中执行，那么训练的 trace 函数需要用不一样的，因为模型的参数变化了，需要重新进行编译。示例代码中则是采用在新的执行中读取检查点重新编译的方法。
在 QAT 模式训练完成后，继续保存检查点，执行 inference.py 并设置 mode 为 quantized ，这里需要将原始 Float 模型转换为 QAT 模型之后再加载检查点。
from megengine.quantization.quantize import quantize_qat
model = ResNet18()
if args.mode != "normal":
quantize_qat(model, ema_fakequant_qconfig)
if args.checkpoint:
logger.info("Load pretrained weights from %s", args.checkpoint)
ckpt = mge.load(args.checkpoint)
ckpt = ckpt["state_dict"] if "state_dict" in ckpt else ckpt
model.load_state_dict(ckpt, strict=False)
模型转换为量化模型包括以下几步：
from megengine.quantization.quantize import quantize
# 定义trace函数，打开capture_as_const以进行dump
@jit.trace(capture_as_const=True)
def infer_func(processed_img):
model.eval()
logits = model(processed_img)
probs = F.softmax(logits)
return probs
# 执行模型转换
if args.mode == "quantized":
quantize(model)
# 准备数据
processed_img = transform.apply(image)[np.newaxis, :]
if args.mode == "normal":
processed_img = processed_img.astype("float32")
elif args.mode == "quantized":
processed_img = processed_img.astype("int8")
# 执行一遍evaluation
probs = infer_func(processed_img)
# 将模型 dump 导出
infer_func.dump(output_file, arg_names=["data"])
至此，便得到了一个可用于部署的量化模型。
