model = build_detector(        cfg.model,        train_cfg=cfg.get('train_cfg'),        test_cfg=cfg.get('test_cfg'))    model.init_weights()# 加载config里的 init_cfg

set_march(March.BAYES)

    # qat: run fuse_module to fuse conv+bn/relu/add op    model.backbone.fuse_modules()    model.neck.fuse_modules()    model.bbox_head.fuse_modules()

    # qat: set qconfig for float model    model.qconfig = get_default_qat_qconfig()    # qat: set default_qat_out_qconfig for last conv    for m in model.bbox_head.convs_pred:        m.qconfig = get_default_qat_out_qconfig()    # qat: set None for loss qconfig, loss should be quantized    model.bbox_head.loss_cls.qconfig = None    model.bbox_head.loss_conf.qconfig = None    model.bbox_head.loss_xy.qconfig = None    model.bbox_head.loss_wh.qconfig = None

    qat_model = prepare_qat(model)    qat_model.to(torch.device("cuda:1"))

train_detector(        qat_model,        datasets,        cfg,        distributed=distributed,        validate=(not args.no_validate),        timestamp=timestamp,        meta=meta)

quantized_model = convert(qat_model.eval())

    deploy_model = DeployModel(        quantized_model.backbone, quantized_model.neck,        quantized_model.bbox_head).to(torch.device("cuda:1"))    example_input = torch.randn(size=(24, 3, 320, 320), device=torch.device("cuda:1"))

    traced_model = torch.jit.trace(deploy_model.eval(), example_input)    traced_model.to(torch.device("cpu"))    example_input.to(torch.device("cpu"))    check_model(traced_model, example_input, advice=1)    compile_model(traced_model, [example_input], opt=0, hbm="model.hbm")

1. 准备好浮点模型，加载训好的浮点权重2. 设置BPU架构3. 算子融合（eager模式需要，fx可省略）4. 设置model的量化配置-----------------calib_model-------------------calib_model = prepare_qat(float_model)calib_model.eval() # 使bn、dropout等处于正确的状态set_fake_quantize(calib_model, FakeQuantState.CALIBRATION) # 不进行伪量化操作，仅观测算子输入输出统计量，更新scale#校准训练（可复用浮点的train_detector，替换model即可）train_detector(        calib_model,        datasets,        cfg,        distributed=distributed,        validate=(not args.no_validate),        timestamp=timestamp,        meta=meta) #校准精度验证calib_model.eval()set_fake_quantize(calib_model, FakeQuantState.VALIDATION)val(calib_model,val_dataloader,device) -----------此时calib_model里的scale已经更新了-------------------------qat_model = prepare_qat(float_model)-----------qat_model加载calib训练好的模型权重，开始qat训练-----------------------------------------------train_detector(        qat_model,        datasets,        cfg,        distributed=distributed,        validate=(not args.no_validate),        timestamp=timestamp,        meta=meta)

from horizon_plugin_pytorch.quantization import QuantStub
self.quant = QuantStub（scale=1/128） # 一般 pyramid 输入的 Quant 层，需要手动设置 scale=1/128def fuse_modules（self）:
x = self.quant(x)

# Copyright (c) OpenMMLab. All rights reserved.import warnings
import torch.nn as nnfrom mmcv.cnn import ConvModulefrom mmcv.runner import BaseModulefrom torch.nn.modules.batchnorm import _BatchNormfrom horizon_plugin_pytorch.quantization import QuantStub
from ..builder import BACKBONESfrom ..utils import InvertedResidual, make_divisibleimport torch
@BACKBONES.register_module()class MobileNetV2(BaseModule):    arch_settings = [[1, 16, 1, 1], [6, 24, 2, 2], [6, 32, 3, 2],                     [6, 64, 4, 2], [6, 96, 3, 1], [6, 160, 3, 2],                     [6, 320, 1, 1]]
    def __init__(self,                 widen_factor=1.,                 out_indices=(1, 2, 4, 7),                 frozen_stages=-1,                 conv_cfg=None,                 norm_cfg=dict(type='BN'),                 act_cfg=dict(type='ReLU6'),                 norm_eval=False,                 with_cp=False,                 pretrained=None,                 init_cfg=None):        super(MobileNetV2, self).__init__(init_cfg)        # qat: model start with Quantization node        # and set scale=1/128        self.quant = QuantStub(scale=1/128) # 一般pyramid输入的Quant层，需要手动设置scale=1/128        self.pretrained = pretrained        assert not (init_cfg and pretrained), \            'init_cfg and pretrained cannot be specified at the same time'        if isinstance(pretrained, str):            warnings.warn('DeprecationWarning: pretrained is deprecated, '                          'please use "init_cfg" instead')            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)        elif pretrained is None:            if init_cfg is None:                self.init_cfg = [                    dict(type='Kaiming', layer='Conv2d'),                    dict(                        type='Constant',                        val=1,                        layer=['_BatchNorm', 'GroupNorm'])                ]        else:            raise TypeError('pretrained must be a str or None')
        self.widen_factor = widen_factor        self.out_indices = out_indices        if not set(out_indices).issubset(set(range(0, 8))):            raise ValueError('out_indices must be a subset of range'                             f'(0, 8). But received {out_indices}')
        if frozen_stages not in range(-1, 8):            raise ValueError('frozen_stages must be in range(-1, 8). '                             f'But received {frozen_stages}')        self.out_indices = out_indices        self.frozen_stages = frozen_stages        self.conv_cfg = conv_cfg        self.norm_cfg = norm_cfg        self.act_cfg = act_cfg        self.norm_eval = norm_eval        self.with_cp = with_cp
        self.in_channels = make_divisible(32 * widen_factor, 8)
        self.conv1 = ConvModule(            in_channels=3,            out_channels=self.in_channels,            kernel_size=3,            stride=2,            padding=1,            conv_cfg=self.conv_cfg,            norm_cfg=self.norm_cfg,            act_cfg=self.act_cfg)
        self.layers = []
        for i, layer_cfg in enumerate(self.arch_settings):            expand_ratio, channel, num_blocks, stride = layer_cfg            out_channels = make_divisible(channel * widen_factor, 8)            inverted_res_layer = self.make_layer(                out_channels=out_channels,                num_blocks=num_blocks,                stride=stride,                expand_ratio=expand_ratio)            layer_name = f'layer{i + 1}'            self.add_module(layer_name, inverted_res_layer)            self.layers.append(layer_name)
        if widen_factor > 1.0:            self.out_channel = int(1280 * widen_factor)        else:            self.out_channel = 1280
        layer = ConvModule(            in_channels=self.in_channels,            out_channels=self.out_channel,            kernel_size=1,            stride=1,            padding=0,            conv_cfg=self.conv_cfg,            norm_cfg=self.norm_cfg,            act_cfg=self.act_cfg)        self.add_module('conv2', layer)        self.layers.append('conv2')
    def make_layer(self, out_channels, num_blocks, stride, expand_ratio):        """Stack InvertedResidual blocks to build a layer for MobileNetV2.
        Args:            out_channels (int): out_channels of block.            num_blocks (int): number of blocks.            stride (int): stride of the first block. Default: 1            expand_ratio (int): Expand the number of channels of the                hidden layer in InvertedResidual by this ratio. Default: 6.        """        layers = []        for i in range(num_blocks):            if i >= 1:                stride = 1            layers.append(                InvertedResidual(                    self.in_channels,                    out_channels,                    mid_channels=int(round(self.in_channels * expand_ratio)),                    stride=stride,                    with_expand_conv=expand_ratio != 1,                    conv_cfg=self.conv_cfg,                    norm_cfg=self.norm_cfg,                    act_cfg=self.act_cfg,                    with_cp=self.with_cp))            self.in_channels = out_channels
        return nn.Sequential(*layers)
    def _freeze_stages(self):        if self.frozen_stages >= 0:            for param in self.conv1.parameters():                param.requires_grad = False        for i in range(1, self.frozen_stages + 1):            layer = getattr(self, f'layer{i}')            layer.eval()            for param in layer.parameters():                param.requires_grad = False        # qat: do fuse model    def fuse_modules(self):        self.conv1.fuse_modules()        for layer_name in self.layers:            layer = getattr(self, layer_name)            if hasattr(layer, "fuse_modules"):                layer.fuse_modules()            elif isinstance(layer, nn.Sequential):                for m in layer:                    if hasattr(m, "fuse_modules"):                        m.fuse_modules()
    def forward(self, x):        """Forward function."""        # qat: qat model start with QuantStub        x = self.quant(x)        x = self.conv1(x)        outs = []        for i, layer_name in enumerate(self.layers):            layer = getattr(self, layer_name)            x = layer(x)            if i in self.out_indices:                outs.append(x)        return tuple(outs)
    def train(self, mode=True):        """Convert the model into training mode while keep normalization layer        frozen."""        super(MobileNetV2, self).train(mode)        self._freeze_stages()        if mode and self.norm_eval:            for m in self.modules():                # trick: eval have effect on BatchNorm only                if isinstance(m, _BatchNorm):                    m.eval()

class ConvModule(nn.Module):...# qat: fuse conv + bn/relu    def fuse_modules(self):        fuse_list = None        if self.with_norm:            if self.with_activation:                fuse_list = ["conv", self.norm_name, "activate"] # conv+bn+relu            else:                fuse_list = ["conv", self.norm_name] # conv+bn        else:            if self.with_activation:                fuse_list = ["conv", "activate"] # conv+relu        if fuse_list is not None:            torch.quantization.fuse_modules(                self,                fuse_list,                inplace=True,                fuser_func=quantization.fuse_known_modules,            )

self.dequant = nn.ModuleList() # 不止1个反量化节点，用list包起来
self.dequant.append(DeQuantStub())
def fuse_modules(self):
pred_map = self.dequant[i](self.convs_pred[i](x))

class YOLOV3Head(BaseDenseHead, BBoxTestMixin):
    def __init__(self,                 num_classes,                 in_channels,                 out_channels=(1024, 512, 256),                 anchor_generator=dict(                     type='YOLOAnchorGenerator',                     base_sizes=[[(116, 90), (156, 198), (373, 326)],                                 [(30, 61), (62, 45), (59, 119)],                                 [(10, 13), (16, 30), (33, 23)]],                     strides=[32, 16, 8]),                 bbox_coder=dict(type='YOLOBBoxCoder'),                 featmap_strides=[32, 16, 8],                 one_hot_smoother=0.,                 conv_cfg=None,                 norm_cfg=dict(type='BN', requires_grad=True),                 # qat                 # act_cfg=dict(type='LeakyReLU', negative_slope=0.1),                 act_cfg=dict(type='ReLU'),                 loss_cls=dict(                     type='CrossEntropyLoss',                     use_sigmoid=True,                     loss_weight=1.0),                 loss_conf=dict(                     type='CrossEntropyLoss',                     use_sigmoid=True,                     loss_weight=1.0),                 loss_xy=dict(                     type='CrossEntropyLoss',                     use_sigmoid=True,                     loss_weight=1.0),                 loss_wh=dict(type='MSELoss', loss_weight=1.0),                 train_cfg=None,                 test_cfg=None,                 init_cfg=dict(                     type='Normal', std=0.01,                     override=dict(name='convs_pred'))):        super(YOLOV3Head, self).__init__(init_cfg)        # Check params        assert (len(in_channels) == len(out_channels) == len(featmap_strides))
        self.num_classes = num_classes        self.in_channels = in_channels        self.out_channels = out_channels        self.featmap_strides = featmap_strides        self.train_cfg = train_cfg        self.test_cfg = test_cfg        if self.train_cfg:            self.assigner = build_assigner(self.train_cfg.assigner)            if hasattr(self.train_cfg, 'sampler'):                sampler_cfg = self.train_cfg.sampler            else:                sampler_cfg = dict(type='PseudoSampler')            self.sampler = build_sampler(sampler_cfg, context=self)        self.fp16_enabled = False
        self.one_hot_smoother = one_hot_smoother
        self.conv_cfg = conv_cfg        self.norm_cfg = norm_cfg        self.act_cfg = act_cfg
        self.bbox_coder = build_bbox_coder(bbox_coder)
        self.prior_generator = build_prior_generator(anchor_generator)
        self.loss_cls = build_loss(loss_cls)        self.loss_conf = build_loss(loss_conf)        self.loss_xy = build_loss(loss_xy)        self.loss_wh = build_loss(loss_wh)
        self.num_base_priors = self.prior_generator.num_base_priors[0]        assert len(            self.prior_generator.num_base_priors) == len(featmap_strides)        self._init_layers()
    def _init_layers(self):        self.convs_bridge = nn.ModuleList()        self.convs_pred = nn.ModuleList()        self.dequant = nn.ModuleList() # 不止1个反量化节点，用list包起来        for i in range(self.num_levels):            conv_bridge = ConvModule(                self.in_channels[i],                self.out_channels[i],                3,                padding=1,                conv_cfg=self.conv_cfg,                norm_cfg=self.norm_cfg,                act_cfg=self.act_cfg)            conv_pred = nn.Conv2d(self.out_channels[i],                                  self.num_base_priors * self.num_attrib, 1)
            self.convs_bridge.append(conv_bridge)            self.convs_pred.append(conv_pred)            self.dequant.append(DeQuantStub())
    def fuse_modules(self):        for m in self.convs_bridge:            m.fuse_modules()
    def forward(self, feats):        """Forward features from the upstream network.
        Args:            feats (tuple[Tensor]): Features from the upstream network, each is                a 4D-tensor.
        Returns:            tuple[Tensor]: A tuple of multi-level predication map, each is a                4D-tensor of shape (batch_size, 5+num_classes, height, width).        """
        assert len(feats) == self.num_levels        pred_maps = []        for i in range(self.num_levels):            x = feats[i]            x = self.convs_bridge[i](x)            pred_map = self.dequant[i](self.convs_pred[i](x))            pred_maps.append(pred_map)
        return tuple(pred_maps),

#加载浮点模型权重    model.load_state_dict(torch.load("output/toy_experiments/model_moderate_best_soft_float_131892.pth"))    set_march(March.BAYES) #校准配置    calib_model = prepare_qat_fx(        model,        {"":default_calib_8bit_fake_quant_qconfig,        "module_name":            ...        }).to(device)    calib_model.to(device)    #校准需要全程开启eval()状态    calib_model.eval()    #校准的训练阶段，设置伪量化节点模式为 CALIBRATION    set_fake_quantize(calib_model, FakeQuantState.CALIBRATION)    train(cfg, calib_model, device, distributed)    #校准的评测阶段，设置伪量化节点的模式为 VALIDATION    set_fake_quantize(calib_model, FakeQuantState.VALIDATION)    #加载校准的模型权重    calib_model.load_state_dict(torch.load("output/toy_experiments/model_moderate_best_soft_calib_118633.pth"))    #测试校准的精度    run_test(cfg, calib_model, vis=args.vis, eval_score_iou=args.eval_score_iou, eval_all_depths=args.eval_all_depths) # 11.8650

    #加载浮点模型权重    model.load_state_dict(torch.load("output/toy_experiments/model_moderate_best_soft_float_131892.pth"))    set_march(March.BAYES)    #校准配置    calib_model = prepare_qat_fx(        model,        {"":default_calib_8bit_fake_quant_qconfig,        "module_name":           ...        }).to(device)    calib_model.to(device)    #校准需要全程开启eval()状态    calib_model.eval()    #校准的训练阶段，设置伪量化节点模式为 CALIBRATION    set_fake_quantize(calib_model, FakeQuantState.CALIBRATION)    train(cfg, calib_model, device, distributed)    #校准的评测阶段，设置伪量化节点的模式为 VALIDATION    set_fake_quantize(calib_model, FakeQuantState.VALIDATION)    #加载校准的模型权重    calib_model.load_state_dict(torch.load("output/toy_experiments/model_moderate_best_soft_calib_118633.pth"))    #测试校准的精度    run_test(cfg, calib_model, vis=args.vis, eval_score_iou=args.eval_score_iou, eval_all_depths=args.eval_all_depths) # 11.8650

set_march(March.BAYES)    qat_model = prepare_qat_fx(        model,        {"":default_qat_8bit_fake_quant_qconfig,        "module_name":            '''        }).to(device)    qat_model.to(device)    #加载校准模型权重    qat_model.load_state_dict(torch.load("output/toy_experiments/model_moderate_best_soft_calib_118633.pth"))    #训练阶段，保证模型处于model.train()状态，这样伪量化节点也处于qat模式    train(cfg, qat_model, device, distributed)

  (1): ConvModule2d(    (0): Conv2d(      64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)      (weight_fake_quant): FakeQuantize(        fake_quant_enabled=tensor([1], dtype=torch.uint8), observer_enabled=tensor([1], dtype=torch.uint8),            quant_min=-128, quant_max=127, dtype=qint8, qscheme=torch.per_channel_symmetric, ch_axis=0,         scale=tensor([1., 1., 1.]), zero_point=tensor([0, 0, 0])        (activation_post_process): MovingAveragePerChannelMinMaxObserver(min_val=tensor([]), max_val=tensor([]))      )    )  ))

  (0): ConvModule2d(    (0): ConvReLU2d(      64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)      (weight_fake_quant): FakeQuantize(        fake_quant_enabled=tensor([1], dtype=torch.uint8), observer_enabled=tensor([1], dtype=torch.uint8),            quant_min=-128, quant_max=127, dtype=qint8, qscheme=torch.per_channel_symmetric, ch_axis=0,         scale=tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,                1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,                1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,                1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]), zero_point=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])        (activation_post_process): MovingAveragePerChannelMinMaxObserver(min_val=tensor([]), max_val=tensor([]))      )      (activation_post_process): FakeQuantize(        fake_quant_enabled=tensor([1], dtype=torch.uint8), observer_enabled=tensor([1], dtype=torch.uint8),            quant_min=-128, quant_max=127, dtype=qint8, qscheme=torch.per_tensor_symmetric, ch_axis=-1,         scale=tensor([1.]), zero_point=tensor([0])        (activation_post_process): MovingAverageMinMaxObserver(min_val=tensor([]), max_val=tensor([]))      )    )