RuntimeError: Could not run 'aten::thnn_conv2d_forward' with arguments from the 'QuantizedCPU' backend.

[CrappyGit]

I encountered a runtime error RuntimeError: Could not run 'aten::thnn_conv2d_forward' with arguments from the 'QuantizedCPU' backend. when I tried exporting a COCO object detection model. The error can be reproduced with the code shown below.

The configuration file and datasets I used are customized, the full configuration can be found under the full log and datasets can be replaced by anything else. You can still reproduce this issue by just exporting the model output from model_zoo.get_checkpoint_url("faster_rcnn_fbnetv3g_fpn.yaml") without any further training.

Note that this error only occurred when exporting Faster-RCNN-FBNetV3G-FPN model but Faster-RCNN-FBNetV3A and Faster-RCNN-FBNetV3A-dsmask can be exported smoothly.

There is a PyTorch document where common errors in quantization process are discussed. The document suggests this error is caused by passing a quantized Tensor into a non-quantized kernel and dequantization is the solution.

class M(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.quant = torch.quantization.QuantStub()
        self.conv1 = torch.nn.Conv2d(1, 1, 1)
        # this module will not be quantized (see `qconfig = None` logic below)
        self.conv2 = torch.nn.Conv2d(1, 1, 1)
        self.dequant = torch.quantization.DeQuantStub()

    def forward(self, x):
        # during the convert step, this will be replaced with a
        # `quantize_per_tensor` call
        x = self.quant(x)
        x = self.conv1(x)
        # during the convert step, this will be replaced with a
        # `dequantize` call
        x = self.dequant(x)
        x = self.conv2(x)
        return x

In my case, the class is Conv2d. This error however occurred after post-training quantization(ptq) which is triggered in convert_and_export_predictor function so I'm not sure is dequantizing Tensor after ptq making any sense. I tried adding self.dequant = torch.quantization.DeQuantStub() and x = self.dequant(x) into Conv2d anyway but the result remained unchanged.

Any help would be appreciated.

Instructions To Reproduce the 🐛 Bug:

import detectron2, os, copy
import mobile_cv.lut.lib.pt.flops_utils as flops_utils
from detectron2.utils.logger import setup_logger
from detectron2.data.datasets import register_coco_instances
from d2go.model_zoo import model_zoo
from d2go.runner import GeneralizedRCNNRunner
from d2go.config import temp_defrost
from d2go.export.api import convert_and_export_predictor
from d2go.export.d2_meta_arch import patch_d2_meta_arch
from d2go.setup import (
    basic_argument_parser,
    prepare_for_launch,
    setup_after_launch,
)

def prepare_for_launch():
    runner = GeneralizedRCNNRunner()
    cfg = runner.get_default_cfg()
    cfg.merge_from_file("/content/drive/MyDrive/Detectron2 Data/faster_rcnn_fbnetv3g_fpn_customized.ymal")
    cfg.MODEL_EMA.ENABLED = False
    cfg.DATASETS.TRAIN = ("sports_ball_train",)
    cfg.DATASETS.TEST = ("sports_ball_val",)
    cfg.DATALOADER.NUM_WORKERS = 2
    cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url("faster_rcnn_fbnetv3g_fpn.yaml")
    cfg.SOLVER.IMS_PER_BATCH = 2
    cfg.SOLVER.BASE_LR = 0.00025
    cfg.SOLVER.MAX_ITER = 600
    cfg.SOLVER.STEPS = []  
    cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128

    cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1 

    os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)

    return cfg, runner

def export_predictor_int8(cfg, output_dir, runner):
  patch_d2_meta_arch()

  cfg = copy.deepcopy(cfg)
  setup_after_launch(cfg, output_dir, runner)
  with temp_defrost(cfg):
    cfg.merge_from_list(["MODEL.DEVICE", "cpu"])
  model = runner.build_model(cfg, eval_only=True)

  datasets = list(cfg.DATASETS.TRAIN)
  data_loader = runner.build_detection_test_loader(cfg, datasets)

  first_batch = next(iter(data_loader))
  input_args = (first_batch,)
  #flops_utils.print_model_flops(model, input_args)

  pytorch_model = copy.deepcopy(model)
  predictor_path = convert_and_export_predictor(
    cfg, pytorch_model, "torchscript_mobile_int8@tracing", output_dir, data_loader
  )
  return predictor_path

cfg, runner = prepare_for_launch()
model = runner.build_model(cfg)
final_cfg = runner.do_train(cfg, model, resume=False)["model_final"]
predictor_path = export_predictor_int8(final_cfg, "/content/drive/MyDrive/Detectron2 Data/d2go_fpn_600/output", runner)

The code was run on Colab and the CUDA version was changed to 10.1 by running commands shown below.

%cd /usr/local/
!pwd
!ls
!rm -rf cuda
!ln -s /usr/local/cuda-10.1 /usr/local/cuda

Full logs:

WARNING [06/17 17:25:01 d2go.setup]: Override cfg.OUTPUT_DIR (./output) to be the same as output_dir /content/drive/MyDrive/Detectron2 Data/d2go_fpn_600/output
[06/17 17:25:02 d2go.setup]: Full config saved to /content/drive/MyDrive/Detectron2 Data/d2go_fpn_600/output/config.yaml
[06/17 17:25:02 d2go.setup]: Initializing runner ...
[06/17 17:25:02 d2go.setup]: Using 1 processes per machine. Rank of current process: 0
[06/17 17:25:03 d2go.setup]: Environment info:
----------------------  ---------------------------------------------------------------
sys.platform            linux
Python                  3.7.10 (default, May  3 2021, 02:48:31) [GCC 7.5.0]
numpy                   1.19.5
detectron2              0.4.1 @/usr/local/lib/python3.7/dist-packages/detectron2
Compiler                GCC 7.5
CUDA compiler           CUDA 10.1
detectron2 arch flags   6.0
DETECTRON2_ENV_MODULE   <not set>
PyTorch                 1.8.1+cu101 @/usr/local/lib/python3.7/dist-packages/torch
PyTorch debug build     False
GPU available           True
GPU 0                   Tesla P100-PCIE-16GB (arch=6.0)
CUDA_HOME               /usr/local/cuda
Pillow                  7.1.2
torchvision             0.9.1+cu101 @/usr/local/lib/python3.7/dist-packages/torchvision
torchvision arch flags  3.5, 5.0, 6.0, 7.0, 7.5
fvcore                  0.1.5.post20210617
iopath                  0.1.8
cv2                     4.1.2
----------------------  ---------------------------------------------------------------
PyTorch built with:
  - GCC 7.3
  - C++ Version: 201402
  - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications
  - Intel(R) MKL-DNN v1.7.0 (Git Hash 7aed236906b1f7a05c0917e5257a1af05e9ff683)
  - OpenMP 201511 (a.k.a. OpenMP 4.5)
  - NNPACK is enabled
  - CPU capability usage: AVX2
  - CUDA Runtime 10.1
  - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70
  - CuDNN 7.6.3
  - Magma 2.5.2
  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=10.1, CUDNN_VERSION=7.6.3, CXX_COMPILER=/opt/rh/devtoolset-7/root/usr/bin/c++, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_KINETO -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_VERSION=1.8.1, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, 

[06/17 17:25:03 d2go.setup]: Running with full config:
ABNORMAL_CHECKER:
  ENABLED: False
CUDNN_BENCHMARK: False
D2GO_DATA:
  AUG_OPS:
    TEST: ['ResizeShortestEdgeOp']
    TRAIN: ['ResizeShortestEdgeOp', 'RandomFlipOp']
  DATASETS:
    COCO_INJECTION:
      IM_DIRS: []
      JSON_FILES: []
      KEYPOINT_METADATA: []
      NAMES: []
    DYNAMIC_DATASETS: []
    TEST_CATEGORIES: ()
    TRAIN_CATEGORIES: ()
  MAPPER:
    BACKFILL_SIZE: False
    CATCH_EXCEPTION: True
    NAME: D2GoDatasetMapper
    RETRY: 3
  TEST:
    MAX_IMAGES: 0
    SUBSET_SAMPLING: frontmost
DATALOADER:
  ASPECT_RATIO_GROUPING: True
  FILTER_EMPTY_ANNOTATIONS: True
  NUM_WORKERS: 2
  REPEAT_THRESHOLD: 0.0
  SAMPLER_TRAIN: TrainingSampler
DATASETS:
  PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000
  PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000
  PROPOSAL_FILES_TEST: ()
  PROPOSAL_FILES_TRAIN: ()
  TEST: ('sports_ball_val',)
  TRAIN: ('sports_ball_train',)
  TRAIN_REPEAT_FACTOR: []
EXPORT_CAFFE2:
  USE_HEATMAP_MAX_KEYPOINT: False
GLOBAL:
  HACK: 1.0
INPUT:
  CROP:
    ENABLED: False
    SIZE: [0.9, 0.9]
    TYPE: relative_range
  FORMAT: BGR
  MASK_FORMAT: polygon
  MAX_SIZE_TEST: 1333
  MAX_SIZE_TRAIN: 1333
  MIN_SIZE_TEST: 800
  MIN_SIZE_TRAIN: (640, 672, 704, 736, 768, 800)
  MIN_SIZE_TRAIN_SAMPLING: choice
  RANDOM_FLIP: horizontal
MODEL:
  ANCHOR_GENERATOR:
    ANGLES: [[-90, 0, 90]]
    ASPECT_RATIOS: [[0.5, 1.0, 2.0]]
    NAME: DefaultAnchorGenerator
    OFFSET: 0.0
    SIZES: [[32], [64], [128], [256], [512]]
  BACKBONE:
    FREEZE_AT: 0
    NAME: FBNetV2FpnBackbone
  DDP_FIND_UNUSED_PARAMETERS: False
  DDP_FP16_GRAD_COMPRESS: False
  DEVICE: cuda
  FBNET_V2:
    ARCH: FBNetV3_G_fpn
    ARCH_DEF: []
    NORM: None
    NORM_ARGS: []
    SCALE_FACTOR: 1.0
    STEM_IN_CHANNELS: 3
    WIDTH_DIVISOR: 8
  FPN:
    FUSE_TYPE: sum
    IN_FEATURES: ['trunk1', 'trunk2', 'trunk3', 'trunk4']
    NORM: 
    OUT_CHANNELS: 128
  FROZEN_LAYER_REG_EXP: []
  KEYPOINT_ON: False
  KMEANS_ANCHORS:
    DATASETS: ()
    KMEANS_ANCHORS_ON: False
    NUM_CLUSTERS: 0
    NUM_TRAINING_IMG: 0
    RNG_SEED: 3
  LOAD_PROPOSALS: False
  MASK_ON: False
  META_ARCHITECTURE: GeneralizedRCNN
  PANOPTIC_FPN:
    COMBINE:
      ENABLED: True
      INSTANCES_CONFIDENCE_THRESH: 0.5
      OVERLAP_THRESH: 0.5
      STUFF_AREA_LIMIT: 4096
    INSTANCE_LOSS_WEIGHT: 1.0
  PIXEL_MEAN: [103.53, 116.28, 123.675]
  PIXEL_STD: [1.0, 1.0, 1.0]
  PROPOSAL_GENERATOR:
    MIN_SIZE: 0
    NAME: RPN
  RESNETS:
    DEFORM_MODULATED: False
    DEFORM_NUM_GROUPS: 1
    DEFORM_ON_PER_STAGE: [False, False, False, False]
    DEPTH: 50
    NORM: FrozenBN
    NUM_GROUPS: 1
    OUT_FEATURES: ['res2', 'res3', 'res4', 'res5']
    RES2_OUT_CHANNELS: 256
    RES5_DILATION: 1
    STEM_OUT_CHANNELS: 64
    STRIDE_IN_1X1: True
    WIDTH_PER_GROUP: 64
  RETINANET:
    BBOX_REG_LOSS_TYPE: smooth_l1
    BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0)
    FOCAL_LOSS_ALPHA: 0.25
    FOCAL_LOSS_GAMMA: 2.0
    IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7']
    IOU_LABELS: [0, -1, 1]
    IOU_THRESHOLDS: [0.4, 0.5]
    NMS_THRESH_TEST: 0.5
    NORM: 
    NUM_CLASSES: 80
    NUM_CONVS: 4
    PRIOR_PROB: 0.01
    SCORE_THRESH_TEST: 0.05
    SMOOTH_L1_LOSS_BETA: 0.1
    TOPK_CANDIDATES_TEST: 1000
  ROI_BOX_CASCADE_HEAD:
    BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0))
    IOUS: (0.5, 0.6, 0.7)
  ROI_BOX_HEAD:
    BBOX_REG_LOSS_TYPE: smooth_l1
    BBOX_REG_LOSS_WEIGHT: 1.0
    BBOX_REG_WEIGHTS: (10.0, 10.0, 5.0, 5.0)
    CLS_AGNOSTIC_BBOX_REG: False
    CONV_DIM: 256
    FC_DIM: 1024
    NAME: FBNetV2RoIBoxHead
    NORM: None
    NUM_CONV: 0
    NUM_FC: 0
    POOLER_RESOLUTION: 6
    POOLER_SAMPLING_RATIO: 0
    POOLER_TYPE: ROIAlignV2
    SMOOTH_L1_BETA: 0.0
    TRAIN_ON_PRED_BOXES: False
  ROI_HEADS:
    BATCH_SIZE_PER_IMAGE: 128
    IN_FEATURES: ['p3', 'p4', 'p5', 'p6']
    IOU_LABELS: [0, 1]
    IOU_THRESHOLDS: [0.5]
    NAME: StandardROIHeads
    NMS_THRESH_TEST: 0.5
    NUM_CLASSES: 1
    POSITIVE_FRACTION: 0.25
    PROPOSAL_APPEND_GT: True
    SCORE_THRESH_TEST: 0.05
  ROI_KEYPOINT_HEAD:
    CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512)
    LOSS_WEIGHT: 1.0
    MIN_KEYPOINTS_PER_IMAGE: 1
    NAME: KRCNNConvDeconvUpsampleHead
    NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True
    NUM_KEYPOINTS: 17
    POOLER_RESOLUTION: 14
    POOLER_SAMPLING_RATIO: 0
    POOLER_TYPE: ROIAlignV2
  ROI_MASK_HEAD:
    CLS_AGNOSTIC_MASK: False
    CONV_DIM: 256
    NAME: MaskRCNNConvUpsampleHead
    NORM: 
    NUM_CONV: 4
    POOLER_RESOLUTION: 14
    POOLER_SAMPLING_RATIO: 0
    POOLER_TYPE: ROIAlignV2
  RPN:
    BATCH_SIZE_PER_IMAGE: 256
    BBOX_REG_LOSS_TYPE: smooth_l1
    BBOX_REG_LOSS_WEIGHT: 1.0
    BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0)
    BOUNDARY_THRESH: -1
    CONV_DIMS: [-1]
    HEAD_NAME: FBNetV2RpnHead
    IN_FEATURES: ['p2', 'p3', 'p4', 'p5', 'p6']
    IOU_LABELS: [0, -1, 1]
    IOU_THRESHOLDS: [0.3, 0.7]
    LOSS_WEIGHT: 1.0
    NMS_THRESH: 0.7
    POSITIVE_FRACTION: 0.5
    POST_NMS_TOPK_TEST: 1000
    POST_NMS_TOPK_TRAIN: 2000
    PRE_NMS_TOPK_TEST: 1000
    PRE_NMS_TOPK_TRAIN: 2000
    SMOOTH_L1_BETA: 0.0
  SEM_SEG_HEAD:
    COMMON_STRIDE: 4
    CONVS_DIM: 128
    IGNORE_VALUE: 255
    IN_FEATURES: ['p2', 'p3', 'p4', 'p5']
    LOSS_WEIGHT: 1.0
    NAME: SemSegFPNHead
    NORM: GN
    NUM_CLASSES: 54
  SUBCLASS:
    NUM_LAYERS: 1
    NUM_SUBCLASSES: 0
    SUBCLASS_ID_FETCHER: SubclassFetcher
    SUBCLASS_MAPPING: []
    SUBCLASS_ON: False
  VT_FPN:
    HEADS: 16
    IN_FEATURES: ['res2', 'res3', 'res4', 'res5']
    LAYERS: 3
    MIN_GROUP_PLANES: 64
    NORM: None
    OUT_CHANNELS: 256
    POS_HWS: []
    POS_N_DOWNSAMPLE: []
    TOKEN_C: 1024
    TOKEN_LS: [16, 16, 8, 8]
  WEIGHTS: ./output/model_final.pth
MODEL_EMA:
  DECAY: 0.9998
  DEVICE: 
  ENABLED: False
  USE_EMA_WEIGHTS_FOR_EVAL_ONLY: False
OUTPUT_DIR: /content/drive/MyDrive/Detectron2 Data/d2go_fpn_600/output
QUANTIZATION:
  BACKEND: qnnpack
  CUSTOM_QSCHEME: 
  EAGER_MODE: True
  MODULES: None
  NAME: 
  PTQ:
    CALIBRATION_FORCE_ON_GPU: False
    CALIBRATION_NUM_IMAGES: 1
  QAT:
    BATCH_SIZE_FACTOR: 1.0
    DISABLE_OBSERVER_ITER: 38000
    ENABLED: False
    ENABLE_OBSERVER_ITER: 35000
    FREEZE_BN_ITER: 37000
    START_ITER: 35000
    UPDATE_OBSERVER_STATS_PERIOD: 1
    UPDATE_OBSERVER_STATS_PERIODICALLY: False
RCNN_PREPARE_FOR_EXPORT: default_rcnn_prepare_for_export
RCNN_PREPARE_FOR_QUANT: default_rcnn_prepare_for_quant
RCNN_PREPARE_FOR_QUANT_CONVERT: default_rcnn_prepare_for_quant_convert
SEED: -1
SOLVER:
  AMP:
    ENABLED: False
  AUTO_SCALING_METHODS: ['default_scale_d2_configs', 'default_scale_quantization_configs']
  BASE_LR: 0.00025
  BIAS_LR_FACTOR: 1.0
  CHECKPOINT_PERIOD: 5000
  CLIP_GRADIENTS:
    CLIP_TYPE: value
    CLIP_VALUE: 1.0
    ENABLED: False
    NORM_TYPE: 2.0
  GAMMA: 0.1
  IMS_PER_BATCH: 2
  LR_MULTIPLIER_OVERWRITE: []
  LR_SCHEDULER_NAME: WarmupCosineLR
  MAX_ITER: 60
  MOMENTUM: 0.9
  NESTEROV: False
  OPTIMIZER: sgd
  REFERENCE_WORLD_SIZE: 8
  STEPS: []
  WARMUP_FACTOR: 0.001
  WARMUP_ITERS: 1000
  WARMUP_METHOD: linear
  WEIGHT_DECAY: 0.0001
  WEIGHT_DECAY_BIAS: 0.0001
  WEIGHT_DECAY_NORM: 0.0
TENSORBOARD:
  TEST_VIS_MAX_IMAGES: 16
  TRAIN_LOADER_VIS_MAX_IMAGES: 16
  TRAIN_LOADER_VIS_WRITE_PERIOD: 20
TEST:
  AUG:
    ENABLED: False
    FLIP: True
    MAX_SIZE: 4000
    MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200)
  DETECTIONS_PER_IMAGE: 100
  EVAL_PERIOD: 5000
  EXPECTED_RESULTS: []
  KEYPOINT_OKS_SIGMAS: []
  PRECISE_BN:
    ENABLED: False
    NUM_ITER: 200
VERSION: 2
VIS_PERIOD: 0
[06/17 17:25:03 d2go.setup]: Running with runner: <d2go.runner.default_runner.GeneralizedRCNNRunner object at 0x7fce8dd70ed0>
[06/17 17:25:03 d2go.config.config]: Applying auto scaling method: default_scale_d2_configs
[06/17 17:25:03 d2go.config.config]: Applying auto scaling method: default_scale_quantization_configs
[06/17 17:25:03 d2go.config.config]: Auto-scaled the config according to the actual world size: 
| config key                             | old value   | new value   |
|:---------------------------------------|:------------|:------------|
| QUANTIZATION.QAT.DISABLE_OBSERVER_ITER | 38000       | 304000      |
| QUANTIZATION.QAT.ENABLE_OBSERVER_ITER  | 35000       | 280000      |
| QUANTIZATION.QAT.FREEZE_BN_ITER        | 37000       | 296000      |
| QUANTIZATION.QAT.START_ITER            | 35000       | 280000      |
| SOLVER.BASE_LR                         | 0.00025     | 3.125e-05   |
| SOLVER.IMS_PER_BATCH                   | 2           | 0           |
| SOLVER.MAX_ITER                        | 60          | 480         |
| SOLVER.REFERENCE_WORLD_SIZE            | 8           | 1           |
| SOLVER.STEPS                           | []          | ()          |
| SOLVER.WARMUP_ITERS                    | 1000        | 8000        |
| TEST.EVAL_PERIOD                       | 5000        | 40000       |
[06/17 17:25:03 d2go.modeling.backbone.fbnet_v2]: Build FBNet using unified arch_def:
trunk
- {'block_op': 'conv_k3', 'block_cfg': {'out_channels': 32, 'stride': 2}, 'stage_idx': 0, 'block_idx': 0}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 24, 'stride': 1, 'expansion': 1, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 1}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 24, 'stride': 1, 'expansion': 1, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 2}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 24, 'stride': 1, 'expansion': 1, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 3}
- {'block_op': 'ir_k5', 'block_cfg': {'out_channels': 40, 'stride': 2, 'expansion': 4, 'less_se_channels': False}, 'stage_idx': 1, 'block_idx': 0}
- {'block_op': 'ir_k5', 'block_cfg': {'out_channels': 40, 'stride': 1, 'expansion': 2, 'less_se_channels': False}, 'stage_idx': 1, 'block_idx': 1}
- {'block_op': 'ir_k5', 'block_cfg': {'out_channels': 40, 'stride': 1, 'expansion': 2, 'less_se_channels': False}, 'stage_idx': 1, 'block_idx': 2}
- {'block_op': 'ir_k5', 'block_cfg': {'out_channels': 40, 'stride': 1, 'expansion': 2, 'less_se_channels': False}, 'stage_idx': 1, 'block_idx': 3}
- {'block_op': 'ir_k5', 'block_cfg': {'out_channels': 40, 'stride': 1, 'expansion': 2, 'less_se_channels': False}, 'stage_idx': 1, 'block_idx': 4}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 56, 'stride': 2, 'expansion': 4, 'less_se_channels': False}, 'stage_idx': 2, 'block_idx': 0}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 56, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 2, 'block_idx': 1}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 56, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 2, 'block_idx': 2}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 56, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 2, 'block_idx': 3}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 56, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 2, 'block_idx': 4}
- {'block_op': 'ir_k5', 'block_cfg': {'out_channels': 104, 'stride': 2, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 0}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 104, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 1}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 104, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 2}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 104, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 3}
- {'block_op': 'ir_k3', 'block_cfg': {'out_channels': 104, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 4}
- {'block_op': 'ir_k3_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 5}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 6}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 7}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 8}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 9}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 10}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 11}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 12}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 3, 'block_idx': 13}
- {'block_op': 'ir_k3_se', 'block_cfg': {'out_channels': 264, 'stride': 2, 'expansion': 6, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 0}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 1}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 2}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 3}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 4}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 5}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 6}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 288, 'stride': 1, 'expansion': 6, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 7}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 288, 'stride': 1, 'expansion': 6, 'less_se_channels': False}, 'stage_idx': 4, 'block_idx': 8}
WARNING [06/17 17:25:03 mobile_cv.arch.utils.helper]: Arguments ['width_divisor', 'dw_skip_bnrelu', 'zero_last_bn_gamma'] skipped for op Conv2d
[06/17 17:25:04 d2go.modeling.backbone.fbnet_v2]: Build FBNet using unified arch_def:
rpn
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 160, 'stride': 1, 'expansion': 3, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 0}
[06/17 17:25:04 d2go.modeling.backbone.fbnet_v2]: Build FBNet using unified arch_def:
bbox
- {'block_op': 'ir_k3_se', 'block_cfg': {'out_channels': 264, 'stride': 2, 'expansion': 6, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 0}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 1}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 2}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 3}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 4}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 5}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 264, 'stride': 1, 'expansion': 5, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 6}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 288, 'stride': 1, 'expansion': 6, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 7}
- {'block_op': 'ir_k5_se', 'block_cfg': {'out_channels': 288, 'stride': 1, 'expansion': 6, 'less_se_channels': False}, 'stage_idx': 0, 'block_idx': 8}
[06/17 17:25:04 fvcore.common.checkpoint]: [Checkpointer] Loading from ./output/model_final.pth ...
WARNING [06/17 17:25:04 fvcore.common.checkpoint]: Some model parameters or buffers are not found in the checkpoint:
backbone.fpn_lateral2.bias
backbone.fpn_lateral3.bias
backbone.fpn_lateral4.bias
backbone.fpn_lateral5.bias
backbone.fpn_output2.bias
backbone.fpn_output3.bias
backbone.fpn_output4.bias
backbone.fpn_output5.bias
WARNING [06/17 17:25:04 fvcore.common.checkpoint]: The checkpoint state_dict contains keys that are not used by the model:
  backbone.fpn_lateral2.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_output2.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_lateral3.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_output3.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_lateral4.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_output4.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_lateral5.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
  backbone.fpn_output5.norm.{bias, num_batches_tracked, running_mean, running_var, weight}
[06/17 17:25:04 d2go.runner.default_runner]: Building detection test loader for dataset: ['sports_ball_train'] ...
[06/17 17:25:04 d2go.runner.default_runner]: Using dataset mapper:
D2GoDatasetMapper:
  is_train: False
  image_loader: None
  tfm_gens: 
    - ResizeShortestEdge(short_edge_length=(800, 800), max_size=1333, sample_style='choice')
WARNING [06/17 17:25:04 d2.data.datasets.coco]: 
Category ids in annotations are not in [1, #categories]! We'll apply a mapping for you.

WARNING [06/17 17:25:04 d2.data.datasets.coco]: 
Category ids in annotations are not in [1, #categories]! We'll apply a mapping for you.

[06/17 17:25:04 d2.data.datasets.coco]: Loaded 4262 images in COCO format from /content/drive/MyDrive/Detectron2 Data/sports_ball/train/via_region_data.json
[06/17 17:25:04 d2.data.datasets.coco]: Loaded 4262 images in COCO format from /content/drive/MyDrive/Detectron2 Data/sports_ball/train/via_region_data.json
[06/17 17:25:05 d2.data.common]: Serializing 4262 elements to byte tensors and concatenating them all ...
[06/17 17:25:05 d2.data.common]: Serializing 4262 elements to byte tensors and concatenating them all ...
[06/17 17:25:05 d2.data.common]: Serialized dataset takes 3.10 MiB
[06/17 17:25:05 d2.data.common]: Serialized dataset takes 3.10 MiB
[06/17 17:25:06 d2go.export.api]: The model is not quantized during training, running post training quantization ...
[06/17 17:25:06 d2go.modeling.meta_arch.rcnn]: Setup the model with qconfig:
QConfig(activation=functools.partial(<class 'torch.quantization.observer.HistogramObserver'>, reduce_range=False), weight=functools.partial(<class 'torch.quantization.observer.MinMaxObserver'>, dtype=torch.qint8, qscheme=torch.per_tensor_symmetric))
[06/17 17:25:06 d2go.modeling.quantization]: Prepared the PTQ model for calibration:
GeneralizedRCNN(
  (backbone): QuantWrapSubClass(
    (fpn_lateral2): Conv2d(40, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral3): Conv2d(56, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral4): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral5): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output5): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (top_block): LastLevelMaxPool()
    (bottom_up): FBNetV2Backbone(
      (trunk0): Sequential(
        (fbnetv2_0_0): ConvBNRelu(
          (conv): ConvReLU2d(
            (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
            (1): ReLU(inplace=True)
            (activation_post_process): HistogramObserver()
          )
          (relu): Identity()
        )
        (fbnetv2_0_1): IRFBlock(
          (dw): ConvBNRelu(
            (conv): Conv2d(
              32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              32, 24, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_0_2): IRFBlock(
          (dw): ConvBNRelu(
            (conv): Conv2d(
              24, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=24, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              24, 24, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_0_3): IRFBlock(
          (dw): ConvBNRelu(
            (conv): Conv2d(
              24, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=24, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              24, 24, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
      )
      (trunk1): Sequential(
        (fbnetv2_1_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(24, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              96, 96, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=96, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              96, 40, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_1_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(40, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              80, 80, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=80, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              80, 40, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_1_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(40, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              80, 80, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=80, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              80, 40, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_1_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(40, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              80, 80, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=80, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              80, 40, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_1_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(40, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              80, 80, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=80, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              80, 40, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
      )
      (trunk2): Sequential(
        (fbnetv2_2_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(40, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              160, 160, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=160, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(160, 40, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                40, 160, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              160, 56, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_2_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(56, 168, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              168, 168, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=168, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(168, 40, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                40, 168, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              168, 56, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_2_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(56, 168, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              168, 168, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=168, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(168, 40, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                40, 168, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              168, 56, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_2_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(56, 168, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              168, 168, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=168, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(168, 40, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                40, 168, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              168, 56, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_2_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(56, 168, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              168, 168, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=168, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(168, 40, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                40, 168, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              168, 56, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
      )
      (trunk3): Sequential(
        (fbnetv2_3_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(56, 280, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              280, 280, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=280, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              280, 104, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(104, 312, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              312, 312, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=312, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              312, 104, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(104, 312, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              312, 312, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=312, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              312, 104, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(104, 312, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              312, 312, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=312, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              312, 104, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(104, 312, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              312, 312, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=312, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              312, 104, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_5): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(104, 520, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              520, 520, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=520, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(520, 128, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                128, 520, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              520, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_6): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_7): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_8): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_9): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_10): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_11): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_12): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_3_13): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              480, 480, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=480, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(480, 120, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                120, 480, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              480, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
      )
      (trunk4): Sequential(
        (fbnetv2_4_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              960, 960, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=960, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(960, 240, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                240, 960, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              960, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                328, 1320, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                328, 1320, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                328, 1320, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                328, 1320, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_5): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                328, 1320, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_6): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                328, 1320, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_7): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(264, 1584, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1584, 1584, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1584, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1584, 400, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                400, 1584, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1584, 288, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
        )
        (fbnetv2_4_8): IRFBlock(
          (pw): ConvBNRelu(
            (conv): ConvReLU2d(
              (0): Conv2d(288, 1728, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (1): ReLU(inplace=True)
              (activation_post_process): HistogramObserver()
            )
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): Conv2d(
              1728, 1728, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1728, bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): ConvReLU2d(
                  (0): Conv2d(1728, 432, kernel_size=(1, 1), stride=(1, 1))
                  (1): ReLU(inplace=True)
                  (activation_post_process): HistogramObserver()
                )
                (relu): Identity()
              )
              (1): Conv2d(
                432, 1728, kernel_size=(1, 1), stride=(1, 1)
                (activation_post_process): HistogramObserver()
              )
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): Conv2d(
              1728, 288, kernel_size=(1, 1), stride=(1, 1), bias=False
              (activation_post_process): HistogramObserver()
            )
          )
          (res_conn): TorchAdd(
            (add_func): FloatFunctional(
              (activation_post_process): HistogramObserver()
            )
          )
        )
      )
    )
    (quant_stubs): QuantStubNested(
      (stubs): ModuleList(
        (0): QuantStub(
          (activation_post_process): HistogramObserver()
        )
      )
    )
    (dequant_stubs): QuantStubNested(
      (stubs): ModuleList(
        (0): DeQuantStub()
        (1): DeQuantStub()
        (2): DeQuantStub()
        (3): DeQuantStub()
        (4): DeQuantStub()
      )
    )
  )
  (proposal_generator): RPN(
    (rpn_head): QuantWrapSubClass(
      (rpn_feature): FBNetModule(
        (0): Sequential(
          (fbnetv2_0_0): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(128, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                384, 384, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=384, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  96, 384, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                384, 160, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
          )
        )
      )
      (rpn_regressor): RPNHeadConvRegressor(
        (cls_logits): Conv2d(
          160, 3, kernel_size=(1, 1), stride=(1, 1)
          (activation_post_process): HistogramObserver()
        )
        (bbox_pred): Conv2d(
          160, 12, kernel_size=(1, 1), stride=(1, 1)
          (activation_post_process): HistogramObserver()
        )
      )
      (quant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): QuantStub(
            (activation_post_process): HistogramObserver()
          )
          (1): QuantStub(
            (activation_post_process): HistogramObserver()
          )
          (2): QuantStub(
            (activation_post_process): HistogramObserver()
          )
          (3): QuantStub(
            (activation_post_process): HistogramObserver()
          )
          (4): QuantStub(
            (activation_post_process): HistogramObserver()
          )
        )
      )
      (dequant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): DeQuantStub()
          (1): DeQuantStub()
          (2): DeQuantStub()
          (3): DeQuantStub()
          (4): DeQuantStub()
          (5): DeQuantStub()
          (6): DeQuantStub()
          (7): DeQuantStub()
          (8): DeQuantStub()
          (9): DeQuantStub()
        )
      )
    )
    (anchor_generator): DefaultAnchorGenerator(
      (cell_anchors): BufferList()
    )
  )
  (roi_heads): StandardROIHeads(
    (box_pooler): ROIPooler(
      (level_poolers): ModuleList(
        (0): ROIAlign(output_size=(6, 6), spatial_scale=0.125, sampling_ratio=0, aligned=True)
        (1): ROIAlign(output_size=(6, 6), spatial_scale=0.0625, sampling_ratio=0, aligned=True)
        (2): ROIAlign(output_size=(6, 6), spatial_scale=0.03125, sampling_ratio=0, aligned=True)
        (3): ROIAlign(output_size=(6, 6), spatial_scale=0.015625, sampling_ratio=0, aligned=True)
      )
    )
    (box_head): QuantWrapSubClass(
      (roi_box_conv): FBNetModule(
        (0): Sequential(
          (fbnetv2_0_0): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(128, 768, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                768, 768, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=768, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(768, 192, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  192, 768, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                768, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_1): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  328, 1320, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_2): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  328, 1320, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_3): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  328, 1320, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_4): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  328, 1320, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_5): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  328, 1320, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_6): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1320, 1320, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1320, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1320, 328, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  328, 1320, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1320, 264, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_7): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(264, 1584, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1584, 1584, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1584, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1584, 400, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  400, 1584, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1584, 288, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
          )
          (fbnetv2_0_8): IRFBlock(
            (pw): ConvBNRelu(
              (conv): ConvReLU2d(
                (0): Conv2d(288, 1728, kernel_size=(1, 1), stride=(1, 1), bias=False)
                (1): ReLU(inplace=True)
                (activation_post_process): HistogramObserver()
              )
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): Conv2d(
                1728, 1728, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=1728, bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): ConvReLU2d(
                    (0): Conv2d(1728, 432, kernel_size=(1, 1), stride=(1, 1))
                    (1): ReLU(inplace=True)
                    (activation_post_process): HistogramObserver()
                  )
                  (relu): Identity()
                )
                (1): Conv2d(
                  432, 1728, kernel_size=(1, 1), stride=(1, 1)
                  (activation_post_process): HistogramObserver()
                )
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): FloatFunctional(
                  (activation_post_process): HistogramObserver()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): Conv2d(
                1728, 288, kernel_size=(1, 1), stride=(1, 1), bias=False
                (activation_post_process): HistogramObserver()
              )
            )
            (res_conn): TorchAdd(
              (add_func): FloatFunctional(
                (activation_post_process): HistogramObserver()
              )
            )
          )
        )
      )
      (avgpool): AdaptiveAvgPool2d(output_size=1)
      (quant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): QuantStub(
            (activation_post_process): HistogramObserver()
          )
        )
      )
      (dequant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): DeQuantStub()
        )
      )
    )
    (box_predictor): QuantWrapSubClass(
      (cls_score): Linear(
        in_features=288, out_features=2, bias=True
        (activation_post_process): HistogramObserver()
      )
      (bbox_pred): Linear(
        in_features=288, out_features=4, bias=True
        (activation_post_process): HistogramObserver()
      )
      (quant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): QuantStub(
            (activation_post_process): HistogramObserver()
          )
        )
      )
      (dequant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): DeQuantStub()
          (1): DeQuantStub()
        )
      )
    )
  )
)
[06/17 17:25:06 d2go.modeling.quantization]: Running calibration iter: 0/1
[06/17 17:25:19 d2go.export.api]: Converting quantized model qnnpack...
[06/17 17:25:53 d2go.export.api]: Quantized Model:
GeneralizedRCNN(
  (backbone): QuantWrapSubClass(
    (fpn_lateral2): Conv2d(40, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral3): Conv2d(56, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral4): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (fpn_lateral5): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1))
    (fpn_output5): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (top_block): LastLevelMaxPool()
    (bottom_up): FBNetV2Backbone(
      (trunk0): Sequential(
        (fbnetv2_0_0): ConvBNRelu(
          (conv): QuantizedConvReLU2d(3, 32, kernel_size=(3, 3), stride=(2, 2), scale=0.8501338362693787, zero_point=0, padding=(1, 1))
          (relu): Identity()
        )
        (fbnetv2_0_1): IRFBlock(
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), scale=0.7093896269798279, zero_point=91, padding=(1, 1), groups=32)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(32, 24, kernel_size=(1, 1), stride=(1, 1), scale=0.32593902945518494, zero_point=137)
          )
        )
        (fbnetv2_0_2): IRFBlock(
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(24, 24, kernel_size=(3, 3), stride=(1, 1), scale=0.18133769929409027, zero_point=129, padding=(1, 1), groups=24)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(24, 24, kernel_size=(1, 1), stride=(1, 1), scale=0.0969708040356636, zero_point=113)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.3330376148223877, zero_point=143
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_0_3): IRFBlock(
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(24, 24, kernel_size=(3, 3), stride=(1, 1), scale=0.1158691793680191, zero_point=133, padding=(1, 1), groups=24)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(24, 24, kernel_size=(1, 1), stride=(1, 1), scale=0.04201054573059082, zero_point=144)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.34605783224105835, zero_point=146
              (activation_post_process): Identity()
            )
          )
        )
      )
      (trunk1): Sequential(
        (fbnetv2_1_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(24, 96, kernel_size=(1, 1), stride=(1, 1), scale=0.08736933022737503, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(96, 96, kernel_size=(5, 5), stride=(2, 2), scale=0.1593250036239624, zero_point=113, padding=(2, 2), groups=96)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(96, 40, kernel_size=(1, 1), stride=(1, 1), scale=0.06548008322715759, zero_point=131)
          )
        )
        (fbnetv2_1_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(40, 80, kernel_size=(1, 1), stride=(1, 1), scale=0.013339834287762642, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(80, 80, kernel_size=(5, 5), stride=(1, 1), scale=0.016740281134843826, zero_point=110, padding=(2, 2), groups=80)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(80, 40, kernel_size=(1, 1), stride=(1, 1), scale=0.0031500624027103186, zero_point=123)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.06176501512527466, zero_point=134
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_1_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(40, 80, kernel_size=(1, 1), stride=(1, 1), scale=0.015005774796009064, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(80, 80, kernel_size=(5, 5), stride=(1, 1), scale=0.01408039778470993, zero_point=93, padding=(2, 2), groups=80)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(80, 40, kernel_size=(1, 1), stride=(1, 1), scale=0.0045830262824893, zero_point=73)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.06056637316942215, zero_point=128
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_1_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(40, 80, kernel_size=(1, 1), stride=(1, 1), scale=0.011726685799658298, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(80, 80, kernel_size=(5, 5), stride=(1, 1), scale=0.009524916298687458, zero_point=101, padding=(2, 2), groups=80)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(80, 40, kernel_size=(1, 1), stride=(1, 1), scale=0.0017330370610579848, zero_point=95)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.06146929785609245, zero_point=129
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_1_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(40, 80, kernel_size=(1, 1), stride=(1, 1), scale=0.007583246566355228, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(80, 80, kernel_size=(5, 5), stride=(1, 1), scale=0.0035592708736658096, zero_point=135, padding=(2, 2), groups=80)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(80, 40, kernel_size=(1, 1), stride=(1, 1), scale=0.0006742602563463151, zero_point=119)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.060878101736307144, zero_point=128
              (activation_post_process): Identity()
            )
          )
        )
      )
      (trunk2): Sequential(
        (fbnetv2_2_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(40, 160, kernel_size=(1, 1), stride=(1, 1), scale=0.011912889778614044, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(160, 160, kernel_size=(5, 5), stride=(2, 2), scale=0.03991815075278282, zero_point=115, padding=(2, 2), groups=160)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(160, 40, kernel_size=(1, 1), stride=(1, 1), scale=0.0029640463180840015, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(40, 160, kernel_size=(1, 1), stride=(1, 1), scale=0.0026679884176701307, zero_point=228)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=0.014385252259671688, zero_point=116
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(160, 56, kernel_size=(1, 1), stride=(1, 1), scale=0.00793438870459795, zero_point=115)
          )
        )
        (fbnetv2_2_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(56, 168, kernel_size=(1, 1), stride=(1, 1), scale=0.0010920437052845955, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(168, 168, kernel_size=(5, 5), stride=(1, 1), scale=0.0008342292276211083, zero_point=135, padding=(2, 2), groups=168)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(168, 40, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(40, 168, kernel_size=(1, 1), stride=(1, 1), scale=6.375880911946297e-05, zero_point=98)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=0.00039093021769076586, zero_point=145
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(168, 56, kernel_size=(1, 1), stride=(1, 1), scale=7.621428812853992e-05, zero_point=94)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.007963946089148521, zero_point=113
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_2_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(56, 168, kernel_size=(1, 1), stride=(1, 1), scale=0.0010195026407018304, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(168, 168, kernel_size=(5, 5), stride=(1, 1), scale=0.0007936142501421273, zero_point=91, padding=(2, 2), groups=168)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(168, 40, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(40, 168, kernel_size=(1, 1), stride=(1, 1), scale=7.277222175616771e-05, zero_point=95)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=0.00039561078301630914, zero_point=91
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(168, 56, kernel_size=(1, 1), stride=(1, 1), scale=7.229163747979328e-05, zero_point=187)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.008027761243283749, zero_point=112
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_2_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(56, 168, kernel_size=(1, 1), stride=(1, 1), scale=0.00027073072851635516, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(168, 168, kernel_size=(5, 5), stride=(1, 1), scale=0.00019253291247878224, zero_point=102, padding=(2, 2), groups=168)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(168, 40, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(40, 168, kernel_size=(1, 1), stride=(1, 1), scale=6.987666711211205e-05, zero_point=132)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=9.661383228376508e-05, zero_point=102
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(168, 56, kernel_size=(1, 1), stride=(1, 1), scale=1.6480340491398238e-05, zero_point=132)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.007980186492204666, zero_point=113
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_2_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(56, 168, kernel_size=(1, 1), stride=(1, 1), scale=0.0005524504231289029, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(168, 168, kernel_size=(5, 5), stride=(1, 1), scale=0.0002400965749984607, zero_point=124, padding=(2, 2), groups=168)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(168, 40, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(40, 168, kernel_size=(1, 1), stride=(1, 1), scale=8.812722080620006e-05, zero_point=73)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=0.00012484597391448915, zero_point=129
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(168, 56, kernel_size=(1, 1), stride=(1, 1), scale=2.81129887298448e-05, zero_point=159)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.007957572117447853, zero_point=113
              (activation_post_process): Identity()
            )
          )
        )
      )
      (trunk3): Sequential(
        (fbnetv2_3_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(56, 280, kernel_size=(1, 1), stride=(1, 1), scale=0.0012226185062900186, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(280, 280, kernel_size=(5, 5), stride=(2, 2), scale=0.001530179986730218, zero_point=175, padding=(2, 2), groups=280)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(280, 104, kernel_size=(1, 1), stride=(1, 1), scale=0.0009373266948387027, zero_point=167)
          )
        )
        (fbnetv2_3_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(104, 312, kernel_size=(1, 1), stride=(1, 1), scale=8.4582636191044e-05, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(312, 312, kernel_size=(3, 3), stride=(1, 1), scale=4.209706821711734e-05, zero_point=154, padding=(1, 1), groups=312)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(312, 104, kernel_size=(1, 1), stride=(1, 1), scale=8.65069159772247e-06, zero_point=122)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.0009342883713543415, zero_point=168
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(104, 312, kernel_size=(1, 1), stride=(1, 1), scale=6.381989805959165e-05, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(312, 312, kernel_size=(3, 3), stride=(1, 1), scale=1.539893310109619e-05, zero_point=145, padding=(1, 1), groups=312)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(312, 104, kernel_size=(1, 1), stride=(1, 1), scale=2.219987891294295e-06, zero_point=152)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.0009397048270329833, zero_point=167
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(104, 312, kernel_size=(1, 1), stride=(1, 1), scale=0.00010755240509752184, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(312, 312, kernel_size=(3, 3), stride=(1, 1), scale=4.085125692654401e-05, zero_point=47, padding=(1, 1), groups=312)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(312, 104, kernel_size=(1, 1), stride=(1, 1), scale=9.55848372541368e-06, zero_point=94)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.0009397313697263598, zero_point=167
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(104, 312, kernel_size=(1, 1), stride=(1, 1), scale=3.660437505459413e-05, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(312, 312, kernel_size=(3, 3), stride=(1, 1), scale=1.963492832146585e-05, zero_point=154, padding=(1, 1), groups=312)
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(312, 104, kernel_size=(1, 1), stride=(1, 1), scale=3.0341177534864983e-06, zero_point=132)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=0.0009310279274359345, zero_point=168
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_5): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(104, 520, kernel_size=(1, 1), stride=(1, 1), scale=0.00018172827549278736, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(520, 520, kernel_size=(3, 3), stride=(1, 1), scale=7.848698442103341e-05, zero_point=116, padding=(1, 1), groups=520)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(520, 128, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(128, 520, kernel_size=(1, 1), stride=(1, 1), scale=0.0001210664413520135, zero_point=85)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=3.9188191294670105e-05, zero_point=116
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(520, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.890981184260454e-05, zero_point=97)
          )
        )
        (fbnetv2_3_6): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=1.911950676003471e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.5018854355730582e-06, zero_point=190, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=7.200046820798889e-05, zero_point=101)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=7.540355682067457e-07, zero_point=190
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=121)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.889141640276648e-05, zero_point=97
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_7): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=1.2875838137915707e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.3095192343826056e-06, zero_point=138, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=6.131405098130926e-05, zero_point=89)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=5.939684228906117e-07, zero_point=153
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=61)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.8568976884125732e-05, zero_point=99
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_8): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=1.6371755009458866e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.3133361562722712e-06, zero_point=103, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=0.00010028655378846452, zero_point=61)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=6.430141183955129e-07, zero_point=106
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=100)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.8575032299850136e-05, zero_point=99
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_9): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=1.6438972352261771e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.1340312084939796e-06, zero_point=149, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=8.859753870638087e-05, zero_point=57)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=5.161143121767964e-07, zero_point=157
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=67)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.8881957657868043e-05, zero_point=97
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_10): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=1.4282558140621404e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=8.962684887592332e-07, zero_point=156, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=0.00012169643741799518, zero_point=50)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=4.6200705128285335e-07, zero_point=152
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=48)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.895795139716938e-05, zero_point=98
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_11): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=1.2621263749679201e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.1380574278518907e-06, zero_point=128, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=8.019566303119063e-05, zero_point=61)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=5.698773861695372e-07, zero_point=128
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=101)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.8985765564139e-05, zero_point=98
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_12): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=2.3649929516977863e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.8494765754439868e-06, zero_point=110, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=0.00010181586549151689, zero_point=53)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=9.809293715079548e-07, zero_point=104
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.2404890981088101e-07, zero_point=127)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.8990054741152562e-05, zero_point=99
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_3_13): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 480, kernel_size=(1, 1), stride=(1, 1), scale=2.0782551928277826e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(480, 480, kernel_size=(5, 5), stride=(1, 1), scale=1.499627614975907e-06, zero_point=89, padding=(2, 2), groups=480)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(480, 120, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(120, 480, kernel_size=(1, 1), stride=(1, 1), scale=0.00010415654833195731, zero_point=65)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=7.371511401288444e-07, zero_point=86
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(480, 160, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=85)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.8988346710102633e-05, zero_point=99
              (activation_post_process): Identity()
            )
          )
        )
      )
      (trunk4): Sequential(
        (fbnetv2_4_0): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(160, 960, kernel_size=(1, 1), stride=(1, 1), scale=2.611196805446525e-06, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(960, 960, kernel_size=(3, 3), stride=(2, 2), scale=2.173478151235031e-06, zero_point=107, padding=(1, 1), groups=960)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(960, 240, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(240, 960, kernel_size=(1, 1), stride=(1, 1), scale=8.760602213442326e-05, zero_point=82)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.2160244295955636e-06, zero_point=110
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(960, 264, kernel_size=(1, 1), stride=(1, 1), scale=5.608720812233514e-07, zero_point=75)
          )
        )
        (fbnetv2_4_1): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=63, padding=(2, 2), groups=1320)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=6.037768616806716e-05, zero_point=74)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=32
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=5)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=5.751385856456182e-07, zero_point=74
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_4_2): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=23, padding=(2, 2), groups=1320)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=6.264840340008959e-05, zero_point=61)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=12
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=2)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=5.754035896643472e-07, zero_point=74
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_4_3): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=14, padding=(2, 2), groups=1320)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=6.452084926422685e-05, zero_point=81)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=7
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=1)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=5.751657567998336e-07, zero_point=74
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_4_4): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=9, padding=(2, 2), groups=1320)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=8.022618567338213e-05, zero_point=42)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=5
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=5.751547860199935e-07, zero_point=74
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_4_5): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=17, padding=(2, 2), groups=1320)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=6.953460251679644e-05, zero_point=52)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=8
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=2)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=5.747066325056949e-07, zero_point=74
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_4_6): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=32, padding=(2, 2), groups=1320)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=7.979892689036205e-05, zero_point=39)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=16
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=3)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=5.71201837828994e-07, zero_point=73
              (activation_post_process): Identity()
            )
          )
        )
        (fbnetv2_4_7): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(264, 1584, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1584, 1584, kernel_size=(5, 5), stride=(1, 1), scale=5.027031306781282e-07, zero_point=103, padding=(2, 2), groups=1584)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1584, 400, kernel_size=(1, 1), stride=(1, 1), scale=0.00021970877423882484, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(400, 1584, kernel_size=(1, 1), stride=(1, 1), scale=0.0008652499527670443, zero_point=229)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=2.3715318775430205e-07, zero_point=103
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1584, 288, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=48)
          )
        )
        (fbnetv2_4_8): IRFBlock(
          (pw): ConvBNRelu(
            (conv): QuantizedConvReLU2d(288, 1728, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
            (relu): Identity()
          )
          (dw): ConvBNRelu(
            (conv): QuantizedConv2d(1728, 1728, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=3, padding=(2, 2), groups=1728)
          )
          (se): SEModule(
            (avg_pool): AdaptiveAvgPool2d(output_size=1)
            (se): Sequential(
              (0): ConvBNRelu(
                (conv): QuantizedConvReLU2d(1728, 432, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                (relu): Identity()
              )
              (1): QuantizedConv2d(432, 1728, kernel_size=(1, 1), stride=(1, 1), scale=7.031091081444174e-05, zero_point=89)
              (2): Sigmoid()
            )
            (mul): TorchMultiply(
              (mul_func): QFunctional(
                scale=1.1920928955078125e-07, zero_point=2
                (activation_post_process): Identity()
              )
            )
          )
          (pwl): ConvBNRelu(
            (conv): QuantizedConv2d(1728, 288, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
          )
          (res_conn): TorchAdd(
            (add_func): QFunctional(
              scale=1.1920928955078125e-07, zero_point=48
              (activation_post_process): Identity()
            )
          )
        )
      )
    )
    (quant_stubs): QuantStubNested(
      (stubs): ModuleList(
        (0): Quantize(scale=tensor([1.0769]), zero_point=tensor([115]), dtype=torch.quint8)
      )
    )
    (dequant_stubs): QuantStubNested(
      (stubs): ModuleList(
        (0): DeQuantize()
        (1): DeQuantize()
        (2): DeQuantize()
        (3): DeQuantize()
        (4): DeQuantize()
      )
    )
  )
  (proposal_generator): RPN(
    (rpn_head): QuantWrapSubClass(
      (rpn_feature): FBNetModule(
        (0): Sequential(
          (fbnetv2_0_0): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(128, 384, kernel_size=(1, 1), stride=(1, 1), scale=0.0005485323490574956, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(384, 384, kernel_size=(5, 5), stride=(1, 1), scale=0.00043976091546937823, zero_point=139, padding=(2, 2), groups=384)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(384, 96, kernel_size=(1, 1), stride=(1, 1), scale=0.00013158073124941438, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(96, 384, kernel_size=(1, 1), stride=(1, 1), scale=0.0005567624466493726, zero_point=185)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=0.00019988293934147805, zero_point=126
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(384, 160, kernel_size=(1, 1), stride=(1, 1), scale=4.479621202335693e-05, zero_point=125)
            )
          )
        )
      )
      (rpn_regressor): RPNHeadConvRegressor(
        (cls_logits): QuantizedConv2d(160, 3, kernel_size=(1, 1), stride=(1, 1), scale=0.0011902087135240436, zero_point=38)
        (bbox_pred): QuantizedConv2d(160, 12, kernel_size=(1, 1), stride=(1, 1), scale=0.0003453920071478933, zero_point=231)
      )
      (quant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): Quantize(scale=tensor([0.0031]), zero_point=tensor([119]), dtype=torch.quint8)
          (1): Quantize(scale=tensor([0.0028]), zero_point=tensor([178]), dtype=torch.quint8)
          (2): Quantize(scale=tensor([9.3984e-06]), zero_point=tensor([144]), dtype=torch.quint8)
          (3): Quantize(scale=tensor([1.1921e-07]), zero_point=tensor([18]), dtype=torch.quint8)
          (4): Quantize(scale=tensor([1.1921e-07]), zero_point=tensor([17]), dtype=torch.quint8)
        )
      )
      (dequant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): DeQuantize()
          (1): DeQuantize()
          (2): DeQuantize()
          (3): DeQuantize()
          (4): DeQuantize()
          (5): DeQuantize()
          (6): DeQuantize()
          (7): DeQuantize()
          (8): DeQuantize()
          (9): DeQuantize()
        )
      )
    )
    (anchor_generator): DefaultAnchorGenerator(
      (cell_anchors): BufferList()
    )
  )
  (roi_heads): StandardROIHeads(
    (box_pooler): ROIPooler(
      (level_poolers): ModuleList(
        (0): ROIAlign(output_size=(6, 6), spatial_scale=0.125, sampling_ratio=0, aligned=True)
        (1): ROIAlign(output_size=(6, 6), spatial_scale=0.0625, sampling_ratio=0, aligned=True)
        (2): ROIAlign(output_size=(6, 6), spatial_scale=0.03125, sampling_ratio=0, aligned=True)
        (3): ROIAlign(output_size=(6, 6), spatial_scale=0.015625, sampling_ratio=0, aligned=True)
      )
    )
    (box_head): QuantWrapSubClass(
      (roi_box_conv): FBNetModule(
        (0): Sequential(
          (fbnetv2_0_0): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(128, 768, kernel_size=(1, 1), stride=(1, 1), scale=0.0005679927417077124, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(768, 768, kernel_size=(3, 3), stride=(2, 2), scale=0.0003521842008922249, zero_point=150, padding=(1, 1), groups=768)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(768, 192, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(192, 768, kernel_size=(1, 1), stride=(1, 1), scale=6.309056334430352e-05, zero_point=94)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=0.00017615345132071525, zero_point=150
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(768, 264, kernel_size=(1, 1), stride=(1, 1), scale=5.428988879430108e-05, zero_point=143)
            )
          )
          (fbnetv2_0_1): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=5.013116151530994e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=7.747900667709473e-07, zero_point=115, padding=(2, 2), groups=1320)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=3.8755340938223526e-05, zero_point=102)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=3.875728680213797e-07, zero_point=115
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=108)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=5.4282772907754406e-05, zero_point=143
                (activation_post_process): Identity()
              )
            )
          )
          (fbnetv2_0_2): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=3.1310037229559384e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=9.77845161287405e-07, zero_point=107, padding=(2, 2), groups=1320)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=9.591537673259154e-05, zero_point=75)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=4.889765250482014e-07, zero_point=107
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=62)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=5.4291394917527214e-05, zero_point=143
                (activation_post_process): Identity()
              )
            )
          )
          (fbnetv2_0_3): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=4.679118319472764e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.4510977734971675e-06, zero_point=142, padding=(2, 2), groups=1320)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=4.699787314166315e-05, zero_point=74)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=8.208148187804909e-07, zero_point=144
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=77)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=5.4277472372632474e-05, zero_point=143
                (activation_post_process): Identity()
              )
            )
          )
          (fbnetv2_0_4): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=4.639050985133508e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.0215067050012294e-06, zero_point=91, padding=(2, 2), groups=1320)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=0.00013359281001612544, zero_point=95)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=4.68318120283584e-07, zero_point=85
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=48)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=5.42697380296886e-05, zero_point=143
                (activation_post_process): Identity()
              )
            )
          )
          (fbnetv2_0_5): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=2.2146978153614327e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=8.195603982130706e-07, zero_point=159, padding=(2, 2), groups=1320)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=5.148678974364884e-05, zero_point=54)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=4.1087068325396103e-07, zero_point=159
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=49)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=5.4271928092930466e-05, zero_point=143
                (activation_post_process): Identity()
              )
            )
          )
          (fbnetv2_0_6): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1320, kernel_size=(1, 1), stride=(1, 1), scale=4.5246219997352455e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 1320, kernel_size=(5, 5), stride=(1, 1), scale=1.3171294312996906e-06, zero_point=136, padding=(2, 2), groups=1320)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1320, 328, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(328, 1320, kernel_size=(1, 1), stride=(1, 1), scale=0.00010152328468393534, zero_point=12)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=6.953396223252639e-07, zero_point=142
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1320, 264, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=69)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=5.332106229616329e-05, zero_point=140
                (activation_post_process): Identity()
              )
            )
          )
          (fbnetv2_0_7): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(264, 1584, kernel_size=(1, 1), stride=(1, 1), scale=5.61286606171052e-06, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1584, 1584, kernel_size=(5, 5), stride=(1, 1), scale=1.8154662484448636e-06, zero_point=153, padding=(2, 2), groups=1584)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1584, 400, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(400, 1584, kernel_size=(1, 1), stride=(1, 1), scale=0.00010357669088989496, zero_point=128)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=1.0115625173057197e-06, zero_point=137
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1584, 288, kernel_size=(1, 1), stride=(1, 1), scale=3.674675213005685e-07, zero_point=192)
            )
          )
          (fbnetv2_0_8): IRFBlock(
            (pw): ConvBNRelu(
              (conv): QuantizedConvReLU2d(288, 1728, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
              (relu): Identity()
            )
            (dw): ConvBNRelu(
              (conv): QuantizedConv2d(1728, 1728, kernel_size=(5, 5), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=7, padding=(2, 2), groups=1728)
            )
            (se): SEModule(
              (avg_pool): AdaptiveAvgPool2d(output_size=1)
              (se): Sequential(
                (0): ConvBNRelu(
                  (conv): QuantizedConvReLU2d(1728, 432, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=0)
                  (relu): Identity()
                )
                (1): QuantizedConv2d(432, 1728, kernel_size=(1, 1), stride=(1, 1), scale=0.0002358680940233171, zero_point=140)
                (2): Sigmoid()
              )
              (mul): TorchMultiply(
                (mul_func): QFunctional(
                  scale=1.1920928955078125e-07, zero_point=3
                  (activation_post_process): Identity()
                )
              )
            )
            (pwl): ConvBNRelu(
              (conv): QuantizedConv2d(1728, 288, kernel_size=(1, 1), stride=(1, 1), scale=1.1920928955078125e-07, zero_point=1)
            )
            (res_conn): TorchAdd(
              (add_func): QFunctional(
                scale=3.6752527421413106e-07, zero_point=192
                (activation_post_process): Identity()
              )
            )
          )
        )
      )
      (avgpool): AdaptiveAvgPool2d(output_size=1)
      (quant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): Quantize(scale=tensor([0.0028]), zero_point=tensor([186]), dtype=torch.quint8)
        )
      )
      (dequant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): DeQuantize()
        )
      )
    )
    (box_predictor): QuantWrapSubClass(
      (cls_score): QuantizedLinear(in_features=288, out_features=2, scale=2.147438067368057e-07, zero_point=127, qscheme=torch.per_tensor_affine)
      (bbox_pred): QuantizedLinear(in_features=288, out_features=4, scale=1.1920928955078125e-07, zero_point=4, qscheme=torch.per_tensor_affine)
      (quant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): Quantize(scale=tensor([3.5167e-07]), zero_point=tensor([195]), dtype=torch.quint8)
        )
      )
      (dequant_stubs): QuantStubNested(
        (stubs): ModuleList(
          (0): DeQuantize()
          (1): DeQuantize()
        )
      )
    )
  )
)
[06/17 17:25:54 d2go.export.api]: Using model export method: <class 'd2go.export.torchscript.D2TorchscriptTracingExport'>
[06/17 17:25:54 d2go.export.torchscript]: Tracing and saving TorchScript to /content/drive/MyDrive/Detectron2 Data/d2go_fpn_600/output/torchscript_mobile_int8@tracing ...
/usr/local/lib/python3.7/dist-packages/detectron2/structures/image_list.py:92: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!
  assert t.shape[:-2] == tensors[0].shape[:-2], t.shape
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-13-5acf9d7ee1da> in <module>()
----> 1 predictor_path = export_predictor_int8(final_cfg, "/content/drive/MyDrive/Detectron2 Data/d2go_fpn_600/output", runner)

25 frames
/usr/local/lib/python3.7/dist-packages/detectron2/layers/wrappers.py in forward(self, x)
     83 
     84         x = F.conv2d(
---> 85             x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups
     86         )
     87         if self.norm is not None:

RuntimeError: Could not run 'aten::thnn_conv2d_forward' with arguments from the 'QuantizedCPU' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'aten::thnn_conv2d_forward' is only available for these backends: [CPU, CUDA, BackendSelect, Named, AutogradOther, AutogradCPU, AutogradCUDA, AutogradXLA, AutogradNestedTensor, UNKNOWN_TENSOR_TYPE_ID, AutogradPrivateUse1, AutogradPrivateUse2, AutogradPrivateUse3, Tracer, Autocast, Batched, VmapMode].

CPU: registered at /pytorch/build/aten/src/ATen/RegisterCPU.cpp:5925 [kernel]
CUDA: registered at /pytorch/build/aten/src/ATen/RegisterCUDA.cpp:7100 [kernel]
BackendSelect: fallthrough registered at /pytorch/aten/src/ATen/core/BackendSelectFallbackKernel.cpp:3 [backend fallback]
Named: registered at /pytorch/aten/src/ATen/core/NamedRegistrations.cpp:7 [backend fallback]
AutogradOther: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradCPU: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradCUDA: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradXLA: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradNestedTensor: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
UNKNOWN_TENSOR_TYPE_ID: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradPrivateUse1: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradPrivateUse2: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
AutogradPrivateUse3: registered at /pytorch/torch/csrc/autograd/generated/VariableType_0.cpp:9273 [autograd kernel]
Tracer: registered at /pytorch/torch/csrc/autograd/generated/TraceType_0.cpp:10499 [kernel]
Autocast: fallthrough registered at /pytorch/aten/src/ATen/autocast_mode.cpp:250 [backend fallback]
Batched: registered at /pytorch/aten/src/ATen/BatchingRegistrations.cpp:1016 [backend fallback]
VmapMode: fallthrough registered at /pytorch/aten/src/ATen/VmapModeRegistrations.cpp:33 [backend fallback]

[wat3rBro]

It's a known issue that faster_rcnn_fbnetv3g_fpn has issue with export/quantization, we'll update the config.

[maheshs11]

got same error NotImplementedError: Could not run 'aten::thnn_conv2d_forward' with arguments from the 'QuantizedCPU' backend.

[ValerianGonnot]

@wat3rBro Do you have more informations on the bug location ? Is it only a configuration issue ?

[zhanghang1989]

The Mask-RCNN-FBNetV3G-FPN has been fixed in https://github.com/facebookresearch/d2go/pull/102. I forgot to update Faster-RCNN-FBNetV3G-FPN

Basically, you may change the config and retrain the model:

 ROI_MASK_HEAD:
    NAME: "FBNetV2RoIMaskHead"

[LP308210365]

I got a similar error when i exported Faster-RCNN-FBNetV3G-FPN model with customized COCO datasets using latest d2go version, all the other object detection models can run normally. When i tried to change the config follow the tips above, i still got this error.

Traceback (most recent call last): File "/home/liupeng/sdb1/PythonProject/scaleDetection/detectron2go/fasterrcnn/train.py", line 114, in predictor_path = convert_and_export_predictor( File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/export/api.py", line 151, in convert_and_export_predictor return export_predictor(cfg, pytorch_model, predictor_type, output_dir, data_loader) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/export/api.py", line 174, in export_predictor return default_export_predictor( File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/export/api.py", line 262, in default_export_predictor model_info = _export_single_model( File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/export/api.py", line 196, in _export_single_model load_kwargs = model_export_method.export( File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/export/torchscript.py", line 348, in new_f return old_f(cls, model, input_args, save_path, export_method, export_kwargs) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/export/torchscript.py", line 209, in new_f outputs = model(input_args) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1110, in _call_impl return forward_call(input, kwargs) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/d2go/modeling/meta_arch/rcnn.py", line 388, in forward return self.model.inference(inputs, do_postprocess=False)[0] File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/detectron2/modeling/meta_arch/rcnn.py", line 200, in inference features = self.backbone(images.tensor) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1110, in _call_impl return forward_call(*input, kwargs) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/mobile_cv/arch/utils/quantize_utils.py", line 345, in wrapped_method q_outputs = getattr(ModuleType, wrapped_method_name)(self, *q_args, *q_kwargs) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/detectron2/modeling/backbone/fpn.py", line 128, in forward prev_features = self.lateral_convs0 File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/torch/nn/modules/module.py", line 1110, in _call_impl return forward_call(input, kwargs) File "/home/liupeng/anaconda3/envs/scaleDetection/lib/python3.9/site-packages/detectron2/layers/wrappers.py", line 106, in forward x = F.conv2d( NotImplementedError: Could not run 'aten::_slow_conv2d_forward' with arguments from the 'QuantizedCPU' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'aten::_slow_conv2d_forward' is only available for these backends: [CPU, CUDA, BackendSelect, Python, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradXLA, AutogradLazy, AutogradXPU, AutogradMLC, AutogradHPU, AutogradNestedTensor, AutogradPrivateUse1, AutogradPrivateUse2, AutogradPrivateUse3, Tracer, UNKNOWN_TENSOR_TYPE_ID, Autocast, Batched, VmapMode, Functionalize].

[LP308210365]

@zhanghang1989 Any help would be appreciated

[zhanghang1989]

Do you still have this issue on master branch?

[wat3rBro]

We haven't found a good way to quantize D2's Conv2d yet, so https://github.com/facebookresearch/d2go/pull/163 for the workaround.