分析方向分类器中使用的PACT

2021SC@SDUSC

  将一张 uint8 类型、数值范围在 0~255 的图片归一成 float32 类型、数值范围在 0.0~1.0 的张量，这个过程就是反量化。类似地，我们经常将网络输出的范围在 0.0~1.0 之间的张量调整成数值为 0~255、uint8 类型的图片数据，这个过程就是量化。所以量化本质上只是对数值范围的重新调整。可以明显看出，反量化一般没有信息损失，而量化一般都会有精度损失。因为float32 能保存的数值范围本身就比 uint8 多，因此必定有大量数值无法用 uint8 表示，只能四舍五入成 uint8 型的数值。用 r 表示浮点实数，q 表示量化后的定点整数。浮点和整型之间的换算公式为：

其中，S 是 scale，表示实数和整数之间的比例关系，Z 是 zero point，表示实数中的 0 经过量化后对应的整数，它们的计算方法为：

r max、r min分别是 r 的最大值和最小值，q min、q max同理。这个公式的推导比较简单，很多资料也有详细的介绍，这里不过多介绍。需要强调的一点是，定点整数的 zero point 就代表浮点实数的 0，二者之间的换算不存在精度损失，这一点可以从公式 (2) 中看出来，把 r=0 代入后就可以得到 q=Z。这么做的目的是为了在 padding 时保证浮点数值的 0 和定点整数的 zero point 完全等价，保证定点和浮点之间的表征能够一致。
  模型大小不仅是内存容量问题，也是内存带宽问题。模型在每次预测时都会使用模型的权重，图像相关的应用程序通常需要实时处理数据，这意味着至少 30 FPS（Frame per Second，每秒帧数）。量化使神经网络模型具有更低的延迟、更小的体积和更低的计算功耗。PPOCR已经选择采用MobileNetV3来减小模型的大小，为了继续减小模型规模，量化是一个实用的压缩方法。

  目前量化主要分为线下量化和线上量化两大类。离线量化是指使用KL散度、移动平均等方法确定量化参数，不需要再训练的定点量化方法。在线量化是在训练过程中确定量化参数，比离线量化方式提供更少的量化损失。模型量化主要包括两个部分，一是对权重Weight量化，一是针对激活值Activation量化。同时对两部分进行量化，才能获得最大的计算效率收益。PACT量化（PArameterized Clipping acTivation）是一种新的量化方法，该方法提出在量化激活值之前去掉一些离群点来降低模型量化带来的精度损失。PACT的提出者发现activation的量化可能引起的误差很大。所以他提出截断式ReLU 的激活函数。该截断的上界，即α 是可学习的参数，这保证了每层能够通过训练学习到不一样的量化范围，最大程度降低量化带来的舍入误差。如下图所示，PACT解决问题的方法是，不断裁剪激活值范围，使得激活值分布收窄，从而降低量化映射损失。PACT通过对激活数值做裁剪，从而减少激活

分布中的离群点，使量化模型能够得到一个更合理的量化scale，降低量化损失。PACT的公式如下所示：

  但是，MobileNetV3中的激活函数不仅是ReLU，而且是hard swish。使用普通的PACT量化会导致更高的量化损失。因此，我们将激活预处理公式修改如下，以减少量化损失。更改后的公式不只对大于0的分布进行截断，同时也对小于0的部分做同样的限制，从而更好地得到待量化的范围，降低量化损失。同时，截断阈值是一个可训练的参数，在量化训练过程中，模型会自动的找到一个合理的截断阈值，从而进一步降低量化精度损失。更改后的公式如下图所示：

  PaddleOCR方向分类器基于MobileNetV3模型，原模型大小0.9M，分类准确率为94.03%。PACT在线量化可以在不过分损伤模型准确率的前提下，降低模型的大小，提高预测性能。量化后，方向分类模型大小从0.9M缩减到0.45M，分类准确率为94.65%，量化同样带来了0.62%的精度提升。下图为OCR模型量化前和量化后的性能比较。

代码位置：PaddleOCR-release-2.2>deploy>slim>quantization>quant.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import sys

__dir__ = os.path.dirname(os.path.abspath(__file__))
sys.path.append(__dir__)
sys.path.append(os.path.abspath(os.path.join(__dir__, '..', '..', '..')))
sys.path.append(
    os.path.abspath(os.path.join(__dir__, '..', '..', '..', 'tools')))

import yaml
import paddle
import paddle.distributed as dist

paddle.seed(2)

from ppocr.data import build_dataloader
from ppocr.modeling.architectures import build_model
from ppocr.losses import build_loss
from ppocr.optimizer import build_optimizer
from ppocr.postprocess import build_post_process
from ppocr.metrics import build_metric
from ppocr.utils.save_load import init_model
import tools.program as program
from paddleslim.dygraph.quant import QAT

dist.get_world_size()


class PACT(paddle.nn.Layer):
    def __init__(self):
        super(PACT, self).__init__()
        alpha_attr = paddle.ParamAttr(
            name=self.full_name() + ".pact",
            initializer=paddle.nn.initializer.Constant(value=20),
            learning_rate=1.0,
            regularizer=paddle.regularizer.L2Decay(2e-5))

        self.alpha = self.create_parameter(
            shape=[1], attr=alpha_attr, dtype='float32')

    def forward(self, x):
        out_left = paddle.nn.functional.relu(x - self.alpha)
        out_right = paddle.nn.functional.relu(-self.alpha - x)
        x = x - out_left + out_right
        return x


quant_config = {
    # weight preprocess type, default is None and no preprocessing is performed. 
    'weight_preprocess_type': None,
    # activation preprocess type, default is None and no preprocessing is performed.
    'activation_preprocess_type': None,
    # weight quantize type, default is 'channel_wise_abs_max'
    'weight_quantize_type': 'channel_wise_abs_max',
    # activation quantize type, default is 'moving_average_abs_max'
    'activation_quantize_type': 'moving_average_abs_max',
    # weight quantize bit num, default is 8
    'weight_bits': 8,
    # activation quantize bit num, default is 8
    'activation_bits': 8,
    # data type after quantization, such as 'uint8', 'int8', etc. default is 'int8'
    'dtype': 'int8',
    # window size for 'range_abs_max' quantization. default is 10000
    'window_size': 10000,
    # The decay coefficient of moving average, default is 0.9
    'moving_rate': 0.9,
    # for dygraph quantization, layers of type in quantizable_layer_type will be quantized
    'quantizable_layer_type': ['Conv2D', 'Linear'],
}


def main(config, device, logger, vdl_writer):
    # init dist environment
    if config['Global']['distributed']:
        dist.init_parallel_env()

    global_config = config['Global']

    # build dataloader
    train_dataloader = build_dataloader(config, 'Train', device, logger)
    if config['Eval']:
        valid_dataloader = build_dataloader(config, 'Eval', device, logger)
    else:
        valid_dataloader = None

    # build post process
    post_process_class = build_post_process(config['PostProcess'],
                                            global_config)

    # build model
    # for rec algorithm
    if hasattr(post_process_class, 'character'):
        char_num = len(getattr(post_process_class, 'character'))
        if config['Architecture']["algorithm"] in ["Distillation",
                                                   ]:  # distillation model
            for key in config['Architecture']["Models"]:
                config['Architecture']["Models"][key]["Head"][
                    'out_channels'] = char_num
        else:  # base rec model
            config['Architecture']["Head"]['out_channels'] = char_num
    model = build_model(config['Architecture'])

    quanter = QAT(config=quant_config, act_preprocess=PACT)
    quanter.quantize(model)

    if config['Global']['distributed']:
        model = paddle.DataParallel(model)

    # build loss
    loss_class = build_loss(config['Loss'])

    # build optim
    optimizer, lr_scheduler = build_optimizer(
        config['Optimizer'],
        epochs=config['Global']['epoch_num'],
        step_each_epoch=len(train_dataloader),
        parameters=model.parameters())

    # build metric
    eval_class = build_metric(config['Metric'])
    # load pretrain model
    pre_best_model_dict = init_model(config, model, logger, optimizer)

    logger.info('train dataloader has {} iters, valid dataloader has {} iters'.
                format(len(train_dataloader), len(valid_dataloader)))

    # start train
    program.train(config, train_dataloader, valid_dataloader, device, model,
                  loss_class, optimizer, lr_scheduler, post_process_class,
                  eval_class, pre_best_model_dict, logger, vdl_writer)


if __name__ == '__main__':
    config, device, logger, vdl_writer = program.preprocess(is_train=True)
    main(config, device, logger, vdl_writer)