diff --git a/.gitmodules b/.gitmodules index c0146b4b3ca..5d3ba41eb57 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,5 +1,5 @@ [submodule "external/mmdetection"] - path = external/mmdetection + path = external/mmdetection/submodule url = ../../openvinotoolkit/mmdetection [submodule "external/deep-object-reid"] path = external/deep-object-reid/submodule diff --git a/.pylintrc b/.pylintrc index 5e739c60f25..7916fb5d2f5 100644 --- a/.pylintrc +++ b/.pylintrc @@ -267,7 +267,7 @@ ignored-classes=optparse.Values,thread._local,_thread._local # (useful for modules/projects where namespaces are manipulated during runtime # and thus existing member attributes cannot be deduced by static analysis). It # supports qualified module names, as well as Unix pattern matching. -ignored-modules=ote_sdk,mmseg,segmentation_tasks,mmdet,torchreid,torchreid_tasks,cv2,anomalib,pytorch_lightning,torch,addict,compression,openvino,pandas +ignored-modules=ote_sdk,mmseg,segmentation_tasks,mmdet,detection_tasks,torchreid,torchreid_tasks,cv2,anomalib,pytorch_lightning,torch,addict,compression,openvino,pandas # Show a hint with possible names when a member name was not found. The aspect # of finding the hint is based on edit distance. diff --git a/external/README.md b/external/README.md index 1b396752e2b..125c564e7b5 100644 --- a/external/README.md +++ b/external/README.md @@ -25,21 +25,21 @@ Custom_Image_Classification_EfficientNet-V2-S | EfficientNet-V2-S | 5.76 | 20.23 ## Object Detection ID | Name | Complexity (GFlops) | Model size (MB) | Path ------- | ------- | ------- | ------- | ------- -Custom_Object_Detection_YOLOX | YOLOX | 6.5 | 20.4 | mmdetection/configs/ote/custom-object-detection/cspdarknet_YOLOX/template.yaml -Custom_Object_Detection_Gen3_SSD | SSD | 9.4 | 7.6 | mmdetection/configs/ote/custom-object-detection/gen3_mobilenetV2_SSD/template.yaml -Custom_Object_Detection_Gen3_ATSS | ATSS | 20.6 | 9.1 | mmdetection/configs/ote/custom-object-detection/gen3_mobilenetV2_ATSS/template.yaml +Custom_Object_Detection_YOLOX | YOLOX | 6.5 | 20.4 | mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/template.yaml +Custom_Object_Detection_Gen3_SSD | SSD | 9.4 | 7.6 | mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/template.yaml +Custom_Object_Detection_Gen3_ATSS | ATSS | 20.6 | 9.1 | mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/template.yaml ## Object Counting ID | Name | Complexity (GFlops) | Model size (MB) | Path ------- | ------- | ------- | ------- | ------- -Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B | MaskRCNN-EfficientNetB2B | 68.48 | 13.27 | mmdetection/configs/ote/custom-counting-instance-seg/efficientnetb2b_maskrcnn/template.yaml -Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50 | MaskRCNN-ResNet50 | 533.8 | 177.9 | mmdetection/configs/ote/custom-counting-instance-seg/resnet50_maskrcnn/template.yaml +Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B | MaskRCNN-EfficientNetB2B | 68.48 | 13.27 | mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/template.yaml +Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50 | MaskRCNN-ResNet50 | 533.8 | 177.9 | mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/template.yaml ## Rotated Object Detection ID | Name | Complexity (GFlops) | Model size (MB) | Path ------- | ------- | ------- | ------- | ------- -Custom_Rotated_Detection_via_Instance_Segmentation_MaskRCNN_EfficientNetB2B | MaskRCNN-EfficientNetB2B | 68.48 | 13.27 | mmdetection/configs/ote/rotated_detection/efficientnetb2b_maskrcnn/template.yaml -Custom_Rotated_Detection_via_Instance_Segmentation_MaskRCNN_ResNet50 | MaskRCNN-ResNet50 | 533.8 | 177.9 | mmdetection/configs/ote/rotated_detection/resnet50_maskrcnn/template.yaml +Custom_Rotated_Detection_via_Instance_Segmentation_MaskRCNN_EfficientNetB2B | MaskRCNN-EfficientNetB2B | 68.48 | 13.27 | mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/template.yaml +Custom_Rotated_Detection_via_Instance_Segmentation_MaskRCNN_ResNet50 | MaskRCNN-ResNet50 | 533.8 | 177.9 | mmdetection/configs/rotated_detection/resnet50_maskrcnn/template.yaml ## Semantic Segmentaion ID | Name | Complexity (GFlops) | Model size (MB) | Path diff --git a/external/mmdetection b/external/mmdetection deleted file mode 160000 index 6024bb76624..00000000000 --- a/external/mmdetection +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 6024bb76624c84dfbc9c44c402a97b29ee9b270c diff --git a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/coco_data_pipeline.py b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/coco_data_pipeline.py new file mode 100644 index 00000000000..4ea2f34695b --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/coco_data_pipeline.py @@ -0,0 +1,57 @@ +dataset_type = 'CocoDataset' +img_size = (1024, 1024) + +img_norm_cfg = dict( + mean=(103.53, 116.28, 123.675), std=(1.0, 1.0, 1.0), to_rgb=False) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True, + with_mask=True, poly2mask=False), + dict(type='Resize', img_scale=img_size, keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']) +] + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=img_size, + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] + +data = dict(samples_per_gpu=4, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + adaptive_repeat_times=True, + times=1, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline), + test=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline)) \ No newline at end of file diff --git a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/compression_config.json b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/compression_config.json new file mode 100644 index 00000000000..c41f7a83740 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/compression_config.json @@ -0,0 +1,43 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 1024, 1024] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 1000 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 1000 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/hpo_config.yaml b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/hpo_config.yaml new file mode 100644 index 00000000000..f21916e091c --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 2 + - 4 + - 2 diff --git a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py new file mode 100644 index 00000000000..b9faa07b339 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py @@ -0,0 +1,160 @@ +_base_ = [ + './coco_data_pipeline.py' +] + +model = dict( + type='MaskRCNN', + backbone=dict( + type='efficientnet_b2b', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + pretrained=True, + activation_cfg=dict(type='torch_swish'), + norm_cfg=dict(type='BN', requires_grad=True)), + neck=dict( + type='FPN', + in_channels=[24, 48, 120, 352], + out_channels=80, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=80, + feat_channels=80, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=80, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=80, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=80, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='FCNMaskHead', + num_convs=4, + in_channels=80, + conv_out_channels=80, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))), + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_across_levels=False, + nms_pre=2000, + nms_post=1000, + max_num=1000, + nms_thr=0.8, + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_across_levels=False, + nms_pre=800, + nms_post=500, + max_num=500, + nms_thr=0.8, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.7), + max_per_img=500, + mask_thr_binary=0.5))) + +cudnn_benchmark = True +evaluation = dict(interval=1, metric='mAP', save_best='mAP', iou_thr=[0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9, 0.95]) +optimizer = dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=None) +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=5, + iteration_patience=300, + interval=1, + min_lr=0.000001, + warmup='linear', + warmup_iters=200, + warmup_ratio=0.3333333333333333 +) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +checkpoint_config = dict(interval=5) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +dist_params = dict(backend='nccl') +log_level = 'INFO' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/instance_segmentation/v2/efficientnet_b2b-mask_rcnn-576x576.pth' +resume_from = None +workflow = [('train', 1)] +work_dir = 'output' +custom_hooks = [ + dict(type='EarlyStoppingHook', patience=10, metric='mAP', + interval=1, priority=75, iteration_patience=0), +] +fp16 = dict(loss_scale=512.) diff --git a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/template.yaml b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/template.yaml new file mode 100644 index 00000000000..7640ee62044 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/template.yaml @@ -0,0 +1,52 @@ +# Description. +model_template_id: Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B +name: MaskRCNN-EfficientNetB2B +task_type: INSTANCE_SEGMENTATION +task_family: VISION +instantiation: "CLASS" +summary: Counting algorithm provides counting of objects and object instance masks. This model is based on MaskRCNN-EfficientNetB2B which is faster in training and inference but less accurate. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 4 + learning_rate: + default_value: 0.015 + learning_rate_warmup_iters: + default_value: 200 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 68.48 +size: 13.27 diff --git a/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/coco_data_pipeline.py b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/coco_data_pipeline.py new file mode 100644 index 00000000000..084c5c6e5f6 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/coco_data_pipeline.py @@ -0,0 +1,55 @@ +dataset_type = 'CocoDataset' +img_size = (1344, 800) + +img_norm_cfg = dict(mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True, + with_mask=True, poly2mask=False), + dict(type='Resize', img_scale=img_size, keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']) +] + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='MultiScaleFlipAug', + img_scale=img_size, + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] + +data = dict(samples_per_gpu=4, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + adaptive_repeat_times=True, + times=1, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline), + test=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline)) diff --git a/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/compression_config.json b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/compression_config.json new file mode 100644 index 00000000000..533583e8352 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/compression_config.json @@ -0,0 +1,43 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 1344, 800] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 1000 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 1000 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/hpo_config.yaml b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/hpo_config.yaml new file mode 100644 index 00000000000..f21916e091c --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 2 + - 4 + - 2 diff --git a/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/model.py b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/model.py new file mode 100644 index 00000000000..f857a48bce6 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/model.py @@ -0,0 +1,177 @@ +_base_ = [ + './coco_data_pipeline.py' +] +model = dict( + type='MaskRCNN', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict(type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict(type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict(type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict(type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict(type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', + output_size=14, + sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='FCNMaskHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict(type='CrossEntropyLoss', + use_mask=True, + loss_weight=1.0))), + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_across_levels=False, + nms_pre=2000, + nms_post=1000, + max_num=1000, + nms_thr=0.7, + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_across_levels=False, + nms_pre=1000, + nms_post=1000, + max_num=1000, + nms_thr=0.7, + max_per_img=1000, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict( + type='nms', iou_threshold=0.5, max_num=100), + max_per_img=100, + mask_thr_binary=0.5))) + +cudnn_benchmark = True +evaluation = dict(interval=1, metric='mAP', save_best='mAP', iou_thr=[0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9, 0.95]) +optimizer = dict( + type='SGD', + lr=0.01, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() + +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=5, + iteration_patience=300, + interval=1, + min_lr=0.000001, + warmup='linear', + warmup_iters=200, + warmup_ratio=1.0 / 3) + +checkpoint_config = dict(interval=5) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +# TODO[EUGENE]: UPLOAD TO openvinotoolkit storage repo +load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_fpn_mstrain-poly_3x_coco_20210524_201154-21b550bb.pth' +resume_from = None +workflow = [('train', 1)] +custom_hooks = [ + dict( + type='EarlyStoppingHook', + patience=10, + iteration_patience=0, + metric='mAP', + interval=1, + priority=75) +] diff --git a/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/template.yaml b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/template.yaml new file mode 100644 index 00000000000..b85a688ff55 --- /dev/null +++ b/external/mmdetection/configs/custom-counting-instance-seg/resnet50_maskrcnn/template.yaml @@ -0,0 +1,53 @@ +# Description. +model_template_id: Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50 +name: MaskRCNN-ResNet50 +task_type: INSTANCE_SEGMENTATION +task_family: VISION +instantiation: "CLASS" +summary: Counting algorithm provides counting of objects and object instance masks. This model is based on MaskRCNN-ResNet50 which gives accurate predictions but slower during training and inference. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 4 + learning_rate: + default_value: 0.01 + learning_rate_warmup_iters: + default_value: 200 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# TODO[EUGENE]: WIP +# Stats. +gigaflops: 533.8 +size: 177.9 diff --git a/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/coco_data_pipeline.py b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/coco_data_pipeline.py new file mode 100644 index 00000000000..300850adb09 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/coco_data_pipeline.py @@ -0,0 +1,68 @@ +dataset_type = 'CocoDataset' +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +img_scale = (640, 640) + +train_pipeline = [ + dict(type='Mosaic', img_scale=img_scale, pad_val=114.0), + dict( + type='RandomAffine', + scaling_ratio_range=(0.5, 1.5), + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Resize', keep_ratio=True), + dict(type='Pad', pad_to_square=True, pad_val=114.0), + dict(type='Normalize', **img_norm_cfg), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']) +] + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(416, 416), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=True), + dict(type='RandomFlip'), + dict(type='Pad', size=(416, 416), pad_val=114.0), + dict(type='Normalize', **img_norm_cfg), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img']) + ]) +] + +data = dict( + samples_per_gpu=16, + workers_per_gpu=8, + train=dict( + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=[ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True) + ], + # filter_empty_gt=False, + ), + pipeline=train_pipeline, + dynamic_scale=img_scale), + val=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline), + test=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline)) diff --git a/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/compression_config.json b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/compression_config.json new file mode 100644 index 00000000000..938701302a3 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/compression_config.json @@ -0,0 +1,35 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 640, 640] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization" + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/hpo_config.yaml b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/hpo_config.yaml new file mode 100644 index 00000000000..ded0c7f69b0 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 4 + - 10 + - 2 diff --git a/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/model.py b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/model.py new file mode 100644 index 00000000000..93e4bf70a66 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/model.py @@ -0,0 +1,95 @@ +_base_ = [ + './coco_data_pipeline.py' +] + +model = dict( + type='YOLOX', + backbone=dict( + type='CSPDarknet', + deepen_factor=0.33, + widen_factor=0.375), + neck=dict( + type='YOLOXPAFPN', + in_channels=[96, 192, 384], + out_channels=96, + num_csp_blocks=1), + bbox_head=dict( + type='YOLOXHead', + num_classes=80, + in_channels=96, + feat_channels=96), + train_cfg=dict( + assigner=dict( + type='SimOTAAssigner', + center_radius=2.5)), + # In order to align the source code, the threshold of the val phase is + # 0.01, and the threshold of the test phase is 0.001. + test_cfg=dict( + score_thr=0.01, + nms=dict(type='nms', iou_threshold=0.65), + max_per_img=100)) + +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +optimizer = dict( + type='SGD', + lr=0.0025, + momentum=0.9, + weight_decay=5e-4, + nesterov=True, + paramwise_cfg=dict(norm_decay_mult=0., bias_decay_mult=0.)) +optimizer_config = dict(grad_clip=None) +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=3, + iteration_patience=300, + interval=1, + min_lr=0.000001, + warmup='linear', + warmup_iters=500, + warmup_ratio=0.001 +) + +checkpoint_config = dict(interval=10) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook') + ]) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/yolox_tiny_8x8.pth' +resume_from = None +workflow = [('train', 1)] + +custom_hooks = [ + dict( + type='EarlyStoppingHook', + patience=10, + iteration_patience=1000, + metric='mAP', + interval=1, + priority=75), + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=15, + priority=48), + dict( + type='SyncRandomSizeHook', + ratio_range=(10, 20), + img_scale=(640, 640), + interval=1, + priority=48), + dict( + type='SyncNormHook', + num_last_epochs=15, + interval=1, + priority=48), +] + + + + diff --git a/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/template.yaml b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/template.yaml new file mode 100644 index 00000000000..d441137890e --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/cspdarknet_YOLOX/template.yaml @@ -0,0 +1,55 @@ +# Description. +model_template_id: Custom_Object_Detection_YOLOX +name: YOLOX +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: + Model with fastest inference speed, more than 2x compared to SSD, and comparable, slightly slower, training time. + Works best on datasets with large objects, can struggle with small objects. + +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 16 + learning_rate: + default_value: 0.0025 + learning_rate_warmup_iters: + default_value: 500 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 6.5 +size: 20.4 diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/coco_data_pipeline.py b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/coco_data_pipeline.py new file mode 100644 index 00000000000..dbf27e9d537 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/coco_data_pipeline.py @@ -0,0 +1,59 @@ +dataset_type = 'CocoDataset' +img_size = (992, 736) +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict( + type='Resize', + img_scale=[(992, 736), (896, 736), (1088, 736), (992, 672), (992, 800)], + multiscale_mode='value', + keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']) +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=img_size, + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] +data = dict( + samples_per_gpu=8, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + adaptive_repeat_times=True, + times=1, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + test_mode=True, + pipeline=test_pipeline)) diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/compression_config.json b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/compression_config.json new file mode 100644 index 00000000000..07210929e3c --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/compression_config.json @@ -0,0 +1,76 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 992, 736] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 300 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 300 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "nncf_quantization_pruning": { + "nncf_config": { + "accuracy_aware_training": { + "mode": "adaptive_compression_level", + "params": { + "initial_training_phase_epochs": 5, + "patience_epochs": 5 + } + }, + "compression": [ + { + "algorithm": "filter_pruning", + "params": { + "schedule": "baseline", + "pruning_flops_target": 0.1, + "filter_importance": "geometric_median" + } + }, + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 300 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 300 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization", + "nncf_quantization_pruning" + ] +} diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/hpo_config.yaml b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/hpo_config.yaml new file mode 100644 index 00000000000..05a66a73905 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 4 + - 8 + - 2 diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/model.py b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/model.py new file mode 100644 index 00000000000..0b8786cd466 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/model.py @@ -0,0 +1,92 @@ +_base_ = [ + './coco_data_pipeline.py' +] +model = dict( + type='ATSS', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True), + neck=dict( + type='FPN', + in_channels=[24, 32, 96, 320], + out_channels=64, + start_level=1, + add_extra_convs=True, + extra_convs_on_inputs=False, + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='ATSSHead', + num_classes=80, + in_channels=64, + stacked_convs=4, + feat_channels=64, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +optimizer = dict( + type='SGD', + lr=0.008, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=5, + iteration_patience=600, + interval=1, + min_lr=0.000008, + warmup='linear', + warmup_iters=200, + warmup_ratio=1.0 / 3) + +checkpoint_config = dict(interval=5) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/mobilenet_v2-atss.pth' +resume_from = None +workflow = [('train', 1)] +custom_hooks = [ + dict(type='EarlyStoppingHook', patience=8, iteration_patience=1000, metric='mAP', interval=1, priority=75) +] diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/template.yaml b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/template.yaml new file mode 100644 index 00000000000..0bccf8eaa7a --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_ATSS/template.yaml @@ -0,0 +1,54 @@ +# Description. +model_template_id: Custom_Object_Detection_Gen3_ATSS +name: ATSS +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: + Model with medium inference speed and comparable to SSD training time. Works well enough regardless of dataset + size and difficulty. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 8 + learning_rate: + default_value: 0.008 + learning_rate_warmup_iters: + default_value: 200 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 20.6 +size: 9.1 diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/coco_data_pipeline.py b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/coco_data_pipeline.py new file mode 100644 index 00000000000..0a4a94e3577 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/coco_data_pipeline.py @@ -0,0 +1,60 @@ +dataset_type = 'CocoDataset' +img_size = (864, 864) +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) + +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=img_size, keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']) +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=img_size, + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] +data = dict( + samples_per_gpu=10, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=1, + adaptive_repeat_times=True, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + test_mode=True, + pipeline=test_pipeline)) diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/compression_config.json b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/compression_config.json new file mode 100644 index 00000000000..f8974f3afc1 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/compression_config.json @@ -0,0 +1,79 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 864, 864] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 300 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 300 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "nncf_quantization_pruning": { + "nncf_config": { + "accuracy_aware_training": { + "mode": "adaptive_compression_level", + "params": { + "initial_training_phase_epochs": 5, + "patience_epochs": 5 + } + }, + "compression": [ + { + "algorithm": "filter_pruning", + "ignored_scopes": [ + "{re}SingleStageDetector/SSDHead\\[bbox_head\\].*" + ], + "params": { + "schedule": "baseline", + "pruning_flops_target": 0.1, + "filter_importance": "geometric_median" + } + }, + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 300 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 300 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization", + "nncf_quantization_pruning" + ] +} diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/hpo_config.yaml b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/hpo_config.yaml new file mode 100644 index 00000000000..ded0c7f69b0 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 4 + - 10 + - 2 diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/model.py b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/model.py new file mode 100644 index 00000000000..07745031e37 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/model.py @@ -0,0 +1,103 @@ +_base_ = [ + './coco_data_pipeline.py' +] +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=80, + in_channels=(96, 320), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + reclustering_anchors=True, + widths=[[ + 38.641007923271076, 92.49516032784699, 271.4234764938237, + 141.53469410876247 + ], + [ + 206.04136086566515, 386.6542727907841, + 716.9892752215089, 453.75609561761405, + 788.4629155558277 + ]], + heights=[[ + 48.9243877087132, 147.73088476194903, 158.23569788707474, + 324.14510379107367 + ], + [ + 587.6216059488938, 381.60024152086544, + 323.5988913027747, 702.7486097568518, + 741.4865860938451 + ]]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(0.0, 0.0, 0.0, 0.0), + target_stds=(0.1, 0.1, 0.2, 0.2)), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=False), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1.0, + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + min_bbox_size=0, + score_thr=0.02, + nms=dict(type='nms', iou_threshold=0.45), + max_per_img=200)) + +cudnn_benchmark = True +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +optimizer = dict( + type='SGD', + lr=0.01, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=3, + iteration_patience=600, + interval=1, + min_lr=0.00001, + warmup='linear', + warmup_iters=200, + warmup_ratio=1.0 / 3) + +checkpoint_config = dict(interval=5) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/mobilenet_v2-2s_ssd-992x736.pth' +resume_from = None +workflow = [('train', 1)] +custom_hooks = [ + dict(type='EarlyStoppingHook', patience=5, iteration_patience=1000, metric='mAP', interval=1, priority=75) +] diff --git a/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/template.yaml b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/template.yaml new file mode 100644 index 00000000000..c395eda5169 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_mobilenetV2_SSD/template.yaml @@ -0,0 +1,54 @@ +# Description. +model_template_id: Custom_Object_Detection_Gen3_SSD +name: SSD +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: + Model with fast inference speed and training time. Works better on simple datasets with large and + distinguishable objects. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 10 + learning_rate: + default_value: 0.01 + learning_rate_warmup_iters: + default_value: 200 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 9.4 +size: 7.6 diff --git a/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/coco_data_pipeline.py b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/coco_data_pipeline.py new file mode 100644 index 00000000000..99b00b72c6c --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/coco_data_pipeline.py @@ -0,0 +1,73 @@ +dataset_type = 'CocoDataset' +img_norm_cfg = dict(mean=[123.675, 116.28, 103.53], std=[ + 58.395, 57.12, 57.375], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict( + type='Resize', + img_scale=[(1344, 480), (1344, 960)], + multiscale_mode='range', + keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict( + type='Normalize', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']) +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(1344, 800), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict( + type='Normalize', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] +data = dict( + samples_per_gpu=4, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=1, + adaptive_repeat_times=True, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + test_mode=True, + pipeline=test_pipeline)) diff --git a/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/compression_config.json b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/compression_config.json new file mode 100644 index 00000000000..46dd9c8676e --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/compression_config.json @@ -0,0 +1,43 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 1333, 800] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 1000 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 1000 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/hpo_config.yaml b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/hpo_config.yaml new file mode 100644 index 00000000000..f21916e091c --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 2 + - 4 + - 2 diff --git a/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/model.py b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/model.py new file mode 100644 index 00000000000..775360bf317 --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/model.py @@ -0,0 +1,88 @@ +_base_ = ['./coco_data_pipeline.py'] +model = dict( + type='VFNet', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='VFNetHead', + num_classes=80, + in_channels=256, + stacked_convs=3, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + center_sampling=False, + dcn_on_last_conv=False, + use_atss=True, + use_vfl=True, + loss_cls=dict( + type='VarifocalLoss', + use_sigmoid=True, + alpha=0.75, + gamma=2.0, + iou_weighted=True, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.5), + loss_bbox_refine=dict(type='GIoULoss', loss_weight=2.0)), + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.01, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)) + +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=None) +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=10, + iteration_patience=300, + interval=1, + min_lr=1e-06, + warmup='linear', + warmup_iters=500, + warmup_ratio=0.3333333333333333) +checkpoint_config = dict(interval=100) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/resnet50-vfnet.pth' +resume_from = None +workflow = [('train', 1)] +custom_hooks = [ + dict( + type='EarlyStoppingHook', + patience=15, + metric='mAP', + interval=1, + priority=75, + iteration_patience=500) +] diff --git a/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/template_experimental.yaml b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/template_experimental.yaml new file mode 100644 index 00000000000..f5ac81a492b --- /dev/null +++ b/external/mmdetection/configs/custom-object-detection/gen3_resnet50_VFNet/template_experimental.yaml @@ -0,0 +1,53 @@ +# Description. +model_template_id: Custom_Object_Detection_Gen3_VFNet +name: VFNet +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: + Model achieves the best accuracy but doubles the training time compared to ATSS and has the slowest + inference speed. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 4 + learning_rate: + default_value: 0.01 + learning_rate_warmup_iters: + default_value: 500 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + +# Stats. +gigaflops: 457.4 +size: 126.0 diff --git a/external/mmdetection/configs/face-detection/datasets.md b/external/mmdetection/configs/face-detection/datasets.md new file mode 100644 index 00000000000..e6b04210beb --- /dev/null +++ b/external/mmdetection/configs/face-detection/datasets.md @@ -0,0 +1,47 @@ +## Prepare datasets + +### 1. Download datasets + +Download and unpack it to the `${DATA_DIR}` folder. +* WIDER Face Training Images - [WIDER_train.zip](https://drive.google.com/file/d/0B6eKvaijfFUDQUUwd21EckhUbWs/view?usp=sharing) +* WIDER Face Validation Images - [WIDER_val.zip](https://drive.google.com/file/d/0B6eKvaijfFUDd3dIRmpvSk8tLUk/view?usp=sharing) +* Face annotations - [wider_face_split.zip](http://mmlab.ie.cuhk.edu.hk/projects/WIDERFace/support/bbx_annotation/wider_face_split.zip) + +```bash +export DATA_DIR=${WORK_DIR}/data +``` + +So that `ls -la $DATA_DIR` gives you: +``` +drwxrwxr-x 5 user user 4096 nov 3 12:42 . +drwxr-xr-x 8 user user 4096 nov 3 12:42 .. +drwxrwxr-x 2 user user 4096 nov 31 2017 wider_face_split +drwxrwxr-x 3 user user 4096 nov 18 2015 WIDER_train +drwxrwxr-x 3 user user 4096 nov 18 2015 WIDER_val +``` + +### 2. Convert datasets + +Convert downloaded and extracted annotation to MSCOCO format with `face` as the only one class. + +* Training annotation + + ```bash + export TRAIN_ANN_FILE=${DATA_DIR}/instances_train.json + export TRAIN_IMG_ROOT=${DATA_DIR} + python ./configs/ote/face-detection/tools/wider_to_coco.py \ + ${DATA_DIR}/wider_face_split/wider_face_train_bbx_gt.txt \ + ${DATA_DIR}/WIDER_train/images/ \ + ${TRAIN_ANN_FILE} + ``` + +* Validation annotation + + ```bash + export VAL_ANN_FILE=${DATA_DIR}/instances_val.json + export VAL_IMG_ROOT=${DATA_DIR} + python ./configs/ote/face-detection/tools/wider_to_coco.py \ + ${DATA_DIR}/wider_face_split/wider_face_val_bbx_gt.txt \ + ${DATA_DIR}/WIDER_val/images/ \ + ${VAL_ANN_FILE} + ``` diff --git a/external/mmdetection/configs/face-detection/face-detection-0200/accuracy-check.yml b/external/mmdetection/configs/face-detection/face-detection-0200/accuracy-check.yml new file mode 100644 index 00000000000..5f3b9326b08 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0200/accuracy-check.yml @@ -0,0 +1,26 @@ +models: + - name: face-detection-0200 + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + preprocessing: + - type: resize + size: 256 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0200/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/face-detection/face-detection-0200/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..0e7d4b570b1 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0200/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,35 @@ +models: + - name: face-detection-0200 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + + preprocessing: + - type: resize + size: 256 + + postprocessing: + - type: resize_prediction_boxes + - type: cast_to_int + - type: clip_boxes + size: 1024 + apply_to: annotation + - type: filter + apply_to: annotation + height_range: 64, 1024 + is_empty: True + + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0200/compression_config.json b/external/mmdetection/configs/face-detection/face-detection-0200/compression_config.json new file mode 100644 index 00000000000..763c9b775bf --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0200/compression_config.json @@ -0,0 +1,100 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [1, 3, 256, 256] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.00025 + }, + "runner": { + "max_epochs": 2 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "nncf_sparsity": { + "optimizer": { + "lr": 0.0025 + }, + "runner": { + "max_epochs": 50 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "magnitude_sparsity", + "params": { + "schedule": "multistep", + "multistep_sparsity_levels": [0.2, 0.4, 0.5], + "multistep_steps": [10, 20] + } + } + ] + } + }, + "nncf_pruning": { + "optimizer": { + "lr": 0.05 + }, + "lr_config": { + "policy": "step", + "warmup": "linear", + "warmup_iters": 500, + "warmup_ratio": 0.1, + "step": [40, 60] + }, + "runner": { + "max_epochs": 50 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "filter_pruning", + "pruning_init": 0.05, + "params": { + "schedule": "exponential", + "pruning_init": 0.10, + "pruning_steps": 20, + "pruning_target": 0.30, + "weight_importance": "geometric_median" + }, + "ignored_scopes": [ + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]" + ] + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization", + "nncf_sparsity", + "nncf_pruning" + ] +} diff --git a/external/mmdetection/configs/face-detection/face-detection-0200/model.py b/external/mmdetection/configs/face-detection/face-detection-0200/model.py new file mode 100755 index 00000000000..d363e0c8671 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0200/model.py @@ -0,0 +1,150 @@ +# model settings +input_size = 256 +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=( + [8.0213, 21.4187, 12.544, 29.6107], + [122.0267, 66.048, 109.9093, 43.6053, 64.512]), + heights=( + [12.8, 33.792, 21.76, 53.9307], + [194.1333, 139.008, 106.24, 89.6853, 61.952]), + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2),), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200, + nms_pre_classwise=200)) +cudnn_benchmark = True +# model training and testing settings +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/WIDERFace/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=65, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/train.json', + min_size=17, + img_prefix=data_root, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[40, 55, 65]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +runner = dict(type='EpochBasedRunner', max_epochs=70) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0200.pth' +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/face-detection/face-detection-0200/template_experimental.yaml b/external/mmdetection/configs/face-detection/face-detection-0200/template_experimental.yaml new file mode 100644 index 00000000000..8efd2c4edf6 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0200/template_experimental.yaml @@ -0,0 +1,55 @@ +# Description. +model_template_id: face-detection-0200 +name: Face Detection 0200 +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: Fastest Face Detection for easy and focused faces (MobileNetV2-SSD). +application: Face detection + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 65 + # LR reduction proportionally to the batch size decrease (because gpu_num=1) + learning_rate: + default_value: 0.025 + learning_rate_warmup_iters: + default_value: 1200 + num_iters: + default_value: 70 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 0.01 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 0.82 +size: 1.83 +# Obsolete +# gpu_nums: 2 diff --git a/external/mmdetection/configs/face-detection/face-detection-0202/accuracy-check.yml b/external/mmdetection/configs/face-detection/face-detection-0202/accuracy-check.yml new file mode 100644 index 00000000000..5d7bf4cbd37 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0202/accuracy-check.yml @@ -0,0 +1,26 @@ +models: + - name: face-detection-0202 + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + preprocessing: + - type: resize + size: 384 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0202/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/face-detection/face-detection-0202/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..014f4e35a6f --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0202/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,35 @@ +models: + - name: face-detection-0202 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + + preprocessing: + - type: resize + size: 384 + + postprocessing: + - type: resize_prediction_boxes + - type: cast_to_int + - type: clip_boxes + size: 1024 + apply_to: annotation + - type: filter + apply_to: annotation + height_range: 64, 1024 + is_empty: True + + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0202/compression_config.json b/external/mmdetection/configs/face-detection/face-detection-0202/compression_config.json new file mode 100644 index 00000000000..4c72333ee64 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0202/compression_config.json @@ -0,0 +1,90 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 384, + 384 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.0005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "runner": { + "max_epochs": 5 + }, + "data": { + "samples_per_gpu": 38 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "nncf_pruning": { + "optimizer": { + "lr": 0.05 + }, + "lr_config": { + "policy": "step", + "warmup": "linear", + "warmup_iters": 500, + "warmup_ratio": 0.1, + "step": [50, 80] + }, + "runner": { + "max_epochs": 100 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "filter_pruning", + "pruning_init": 0.05, + "params": { + "schedule": "exponential", + "pruning_init": 0.10, + "pruning_steps": 25, + "pruning_target": 0.30, + "weight_importance": "geometric_median" + }, + "ignored_scopes": [ + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]" + ] + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization", + "nncf_pruning" + ] +} diff --git a/external/mmdetection/configs/face-detection/face-detection-0202/model.py b/external/mmdetection/configs/face-detection/face-detection-0202/model.py new file mode 100755 index 00000000000..c0d3ffaa00c --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0202/model.py @@ -0,0 +1,148 @@ +# model settings +input_size = 384 +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=([9.4 * 1.28, 25.1 * 1.28, 14.7 * 1.28, 34.7 * 1.28], + [143.0 * 1.28, 77.4 * 1.28, 128.8 * 1.28, 51.1 * 1.28, 75.6 * 1.28]), + heights=([15.0 * 1.28, 39.6 * 1.28, 25.5 * 1.28, 63.2 * 1.28], + [227.5 * 1.28, 162.9 * 1.28, 124.5 * 1.28, 105.1 * 1.28, 72.6 * 1.28]), + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2),), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200, + nms_pre_classwise=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/WIDERFace/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=65, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/train.json', + min_size=17, + img_prefix=data_root, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[40, 55, 65]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +runner = dict(type='EpochBasedRunner', max_epochs=70) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs' +load_from = 'https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0202.pth' +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/face-detection/face-detection-0202/template_experimental.yaml b/external/mmdetection/configs/face-detection/face-detection-0202/template_experimental.yaml new file mode 100644 index 00000000000..a02f67a4537 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0202/template_experimental.yaml @@ -0,0 +1,55 @@ +# Description. +model_template_id: face-detection-0202 +name: Face Detection 0202 +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: Fast Face Detection model with a good enough accuracy (MobileNetV2-SSD). +application: Face detection + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 58 + # LR reduction proportionally to the batch size decrease (because gpu_num=1) + learning_rate: + default_value: 0.025 + learning_rate_warmup_iters: + default_value: 1200 + num_iters: + default_value: 70 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 0.01 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 1.84 +size: 1.83 +# Obsolete +# gpu_nums: 2 diff --git a/external/mmdetection/configs/face-detection/face-detection-0204/accuracy-check.yml b/external/mmdetection/configs/face-detection/face-detection-0204/accuracy-check.yml new file mode 100644 index 00000000000..f542fac5095 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0204/accuracy-check.yml @@ -0,0 +1,26 @@ +models: + - name: face-detection-0204 + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + preprocessing: + - type: resize + size: 448 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0204/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/face-detection/face-detection-0204/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..a317afdfeb5 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0204/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,34 @@ +models: + - name: face-detection-0204 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + + preprocessing: + - type: resize + size: 448 + + postprocessing: + - type: resize_prediction_boxes + - type: cast_to_int + - type: clip_boxes + size: 1024 + apply_to: annotation + - type: filter + apply_to: annotation + height_range: 64, 1024 + is_empty: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0204/compression_config.json b/external/mmdetection/configs/face-detection/face-detection-0204/compression_config.json new file mode 100644 index 00000000000..c8c4124c625 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0204/compression_config.json @@ -0,0 +1,90 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 448, + 448 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.0005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "runner": { + "max_epochs": 5 + }, + "data": { + "samples_per_gpu": 28 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "nncf_pruning": { + "optimizer": { + "lr": 0.05 + }, + "lr_config": { + "policy": "step", + "warmup": "linear", + "warmup_iters": 500, + "warmup_ratio": 0.1, + "step": [50, 80] + }, + "runner": { + "max_epochs": 100 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "filter_pruning", + "pruning_init": 0.05, + "params": { + "schedule": "exponential", + "pruning_init": 0.10, + "pruning_steps": 25, + "pruning_flops_target": 0.30, + "weight_importance": "geometric_median" + }, + "ignored_scopes": [ + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]", + "SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]" + ] + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization", + "nncf_pruning" + ] +} diff --git a/external/mmdetection/configs/face-detection/face-detection-0204/model.py b/external/mmdetection/configs/face-detection/face-detection-0204/model.py new file mode 100755 index 00000000000..4a888766eef --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0204/model.py @@ -0,0 +1,148 @@ +# model settings +input_size = 448 +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=([14.0373, 37.4827, 21.952, 51.8187], + [213.5467, 115.584, 192.3413, 76.3093, 112.896]), + heights=([22.4, 59.136, 38.08, 94.3787], + [339.7333, 243.264, 185.92, 156.9493, 108.416]), + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2),), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200, + nms_pre_classwise=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/WIDERFace/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=32, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/train.json', + min_size=17, + img_prefix=data_root, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[40, 55, 65]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +runner = dict(type='EpochBasedRunner', max_epochs=70) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0204.pth' +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/face-detection/face-detection-0204/template_experimental.yaml b/external/mmdetection/configs/face-detection/face-detection-0204/template_experimental.yaml new file mode 100644 index 00000000000..939c545970d --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0204/template_experimental.yaml @@ -0,0 +1,55 @@ +# Description. +model_template_id: face-detection-0204 +name: Face Detection 0204 +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: Medium Face Detection (MobileNetV2-SSD). +application: Face detection + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 32 + # LR reduction proportionally to the batch size decrease (because gpu_num=1) + learning_rate: + default_value: 0.0125 + learning_rate_warmup_iters: + default_value: 1200 + num_iters: + default_value: 70 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 0.01 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 2.52 +size: 1.83 +# Obsolete +# gpu_nums: 4 diff --git a/external/mmdetection/configs/face-detection/face-detection-0205/accuracy-check.yml b/external/mmdetection/configs/face-detection/face-detection-0205/accuracy-check.yml new file mode 100644 index 00000000000..7a82516fd34 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0205/accuracy-check.yml @@ -0,0 +1,26 @@ +models: + - name: face-detection-0205 + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + preprocessing: + - type: resize + size: 416 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0205/compression_config.json b/external/mmdetection/configs/face-detection/face-detection-0205/compression_config.json new file mode 100644 index 00000000000..4ef11932c98 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0205/compression_config.json @@ -0,0 +1,94 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 416, + 416 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.0005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "runner": { + "max_epochs": 5 + }, + "data": { + "samples_per_gpu": 30 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "nncf_pruning": { + "optimizer": { + "lr": 0.05 + }, + "lr_config": { + "policy": "step", + "warmup": "linear", + "warmup_iters": 500, + "warmup_ratio": 0.1, + "step": [50, 80] + }, + "runner": { + "max_epochs": 100 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "filter_pruning", + "pruning_init": 0.05, + "params": { + "schedule": "exponential", + "pruning_steps": 25, + "pruning_flops_target": 0.30, + "weight_importance": "geometric_median" + }, + "ignored_scopes": [ + "FCOS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]", + "FCOS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]", + "FCOS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]", + "FCOS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]", + "FCOS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]", + "FCOS/FCOSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]" + ] + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization", + "nncf_pruning" + ] +} diff --git a/external/mmdetection/configs/face-detection/face-detection-0205/model.py b/external/mmdetection/configs/face-detection/face-detection-0205/model.py new file mode 100755 index 00000000000..cccefc7c435 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0205/model.py @@ -0,0 +1,153 @@ +# model settings +input_size = 416 +width_mult = 1.0 +model = dict( + type='FCOS', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(3, 4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True, + ), + neck=dict( + type='FPN', + in_channels=[int(width_mult * 32), int(width_mult * 96), int(width_mult * 320)], + out_channels=48, + start_level=0, + add_extra_convs=True, + extra_convs_on_inputs=False, # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='FCOSHead', + num_classes=1, + in_channels=48, + stacked_convs=4, + feat_channels=32, + strides=(8, 16, 32, 64, 128), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +# training and testing settings +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/WIDERFace/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=32, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/train.json', + min_size=10, + img_prefix=data_root, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[40, 55, 65]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=100, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +runner = dict(type='EpochBasedRunner', max_epochs=70) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/face-detection-0205-retrained.pth' +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/face-detection/face-detection-0205/template_experimental.yaml b/external/mmdetection/configs/face-detection/face-detection-0205/template_experimental.yaml new file mode 100644 index 00000000000..e861bef0e75 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0205/template_experimental.yaml @@ -0,0 +1,55 @@ +# Description. +model_template_id: face-detection-0205 +name: Face Detection 0205 +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: Medium Face Detection (MobileNetV2-FCOS). +application: Face detection + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 32 + # LR reduction proportionally to the batch size decrease (because gpu_num=1) + learning_rate: + default_value: 0.0125 + learning_rate_warmup_iters: + default_value: 1200 + num_iters: + default_value: 70 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 0.01 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 2.94 +size: 2.02 +# Obsolete +# gpu_nums: 4 diff --git a/external/mmdetection/configs/face-detection/face-detection-0206/compression_config.json b/external/mmdetection/configs/face-detection/face-detection-0206/compression_config.json new file mode 100755 index 00000000000..7b62085189a --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0206/compression_config.json @@ -0,0 +1,44 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [1, 3, 640, 640] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.0008, + "momentum": 0.9, + "weight_decay": 0.0001 + }, + "runner": { + "max_epochs": 1 + }, + "data": { + "samples_per_gpu": 2 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 1025 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 512 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/face-detection/face-detection-0206/model.py b/external/mmdetection/configs/face-detection/face-detection-0206/model.py new file mode 100755 index 00000000000..92e6804ada0 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0206/model.py @@ -0,0 +1,155 @@ +# model settings +input_size = 640 +width_mult = 1.0 +model = dict( + type='ATSS', + backbone=dict( + type='resnet152b', + out_indices=(1, 2, 3, 4), + frozen_stages=-1, + norm_eval=False, + pretrained=True, + ), + neck=dict( + type='RSSH_FPN', + in_channels=[int(width_mult * 256), + int(width_mult * 512), + int(width_mult * 1024), + int(width_mult * 2048), + ], + out_channels=256, + start_level=0, + add_extra_convs=True, + extra_convs_on_inputs=False, # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='ATSSHead', + num_classes=1, + in_channels=256, + stacked_convs=4, + feat_channels=128, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.5), + min_bbox_size=0, + score_thr=0.02, + max_per_img=750)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/WIDERFace/' +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=4, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/train.json', + img_prefix=data_root, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2)) +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[40, 55, 65]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +runner = dict(type='EpochBasedRunner', max_epochs=70) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0206.pth' +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/face-detection/face-detection-0206/template_experimental.yaml b/external/mmdetection/configs/face-detection/face-detection-0206/template_experimental.yaml new file mode 100644 index 00000000000..48e330c51ef --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0206/template_experimental.yaml @@ -0,0 +1,55 @@ +# Description. +model_template_id: face-detection-0206 +name: Face Detection 0206 +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: The most accurate Face Detection model with the best accuracy on the small and difficult faces (ResNet152-ATSS). +application: Face detection + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 4 + # LR reduction proportionally to the batch size decrease (because gpu_num=1) + learning_rate: + default_value: 0.00625 + learning_rate_warmup_iters: + default_value: 1200 + num_iters: + default_value: 70 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 0.01 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 340.06 +size: 63.79 +# Obsolete +# gpu_nums: 8 diff --git a/external/mmdetection/configs/face-detection/face-detection-0207/accuracy-check.yml b/external/mmdetection/configs/face-detection/face-detection-0207/accuracy-check.yml new file mode 100755 index 00000000000..036f247956b --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0207/accuracy-check.yml @@ -0,0 +1,26 @@ +models: + - name: face-detection-0207 + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + datasets: + - name: wider_without_bkgr + data_source: WiderFace/ + annotation_conversion: + converter: mscoco_detection + annotation_file: WiderFace/val.json + has_background: False + sort_annotations: True + use_full_label_map: False + preprocessing: + - type: resize + size: 448 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/face-detection/face-detection-0207/compression_config.json b/external/mmdetection/configs/face-detection/face-detection-0207/compression_config.json new file mode 100644 index 00000000000..377e8ed57fc --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0207/compression_config.json @@ -0,0 +1,46 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 448, + 448 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "runner": { + "max_epochs": 2 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/face-detection/face-detection-0207/model.py b/external/mmdetection/configs/face-detection/face-detection-0207/model.py new file mode 100644 index 00000000000..a48748267d2 --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0207/model.py @@ -0,0 +1,150 @@ +# model settings +input_size = 448 +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='shufflenetv2_w1', + out_indices=(2, 3), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 232), int(width_mult * 464)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=( + [14.0373, 37.4827, 21.952, 51.8187], + [213.5467, 115.584, 192.3413, 76.3093, 112.896]), + heights=( + [22.4, 59.136, 38.08, 94.3787], + [339.7333, 243.264, 185.92, 156.9493, 108.416]), + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2),), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200, + nms_pre_classwise=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/WIDERFace/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=32, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/train.json', + min_size=17, + img_prefix=data_root, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + labels=('face',), + ann_file=data_root + '/val.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='mAP', save_best='mAP') +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[40, 55, 65]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +runner = dict(type='EpochBasedRunner', max_epochs=70) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +load_from = 'https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0207.pth' +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/face-detection/face-detection-0207/template_experimental.yaml b/external/mmdetection/configs/face-detection/face-detection-0207/template_experimental.yaml new file mode 100644 index 00000000000..23c3e08f8fd --- /dev/null +++ b/external/mmdetection/configs/face-detection/face-detection-0207/template_experimental.yaml @@ -0,0 +1,54 @@ +# Description. +model_template_id: face-detection-0207 +name: Face Detection 0207 +task_type: DETECTION +task_family: VISION +instantiation: "CLASS" +summary: One of the fastest Face Detection model (ShuffleNetV2-SSD). +application: Face detection + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 32 + learning_rate: + default_value: 0.05 + learning_rate_warmup_iters: + default_value: 1200 + num_iters: + default_value: 70 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 0.01 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 1.04 +size: 0.81 +# Obsolete +# gpu_nums: 1 diff --git a/external/mmdetection/configs/face-detection/readme.md b/external/mmdetection/configs/face-detection/readme.md new file mode 100644 index 00000000000..f3135150657 --- /dev/null +++ b/external/mmdetection/configs/face-detection/readme.md @@ -0,0 +1,10 @@ +# Face Detection + +| Model Name | Complexity (GFLOPs) | Size (Mp) | AP @ [IoU=0.50:0.95] (%) | AP for faces > 64x64 (%) | WiderFace Easy (%) | WiderFace Medium (%) | WiderFace Hard (%) | Links | GPU_NUM | +| ------------------- | ------ | ----- | ---- | ------ | ------ | ------ | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --- | +| face-detection-0200 | 0.82 | 1.83 | 16.0 | 86.743 | 82.917 | 76.198 | 41.443 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0200.pth), [config](./face-detection-0200/template_experimental.yaml) | 2 | +| face-detection-0202 | 1.84 | 1.83 | 20.3 | 91.938 | 89.382 | 83.919 | 50.189 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0202.pth), [config](./face-detection-0202/template_experimental.yaml) | 2 | +| face-detection-0204 | 2.52 | 1.83 | 21.4 | 92.888 | 90.453 | 85.448 | 52.091 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0204.pth), [config](./face-detection-0204/template_experimental.yaml) | 4 | +| face-detection-0205 | 2.94 | 2.02 | 22.7 | 93.995 | 92.606 | 87.556 | 56.221 | [snapshot](https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/face-detection-0205-retrained.pth), [config](./face-detection-0205/template_experimental.yaml) | 3 | +| face-detection-0206 | 340.06 | 63.79 | 34.2 | 94.274 | 94.281 | 93.207 | 84.439 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0206.pth), [config](./face-detection-0206/template_experimental.yaml) | 8 | +| face-detection-0207 | 1.04 | 0.81 | 17.2 | 88.17 | 84.406 | 76.748 | 43.452 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/face-detection-0207.pth), [config](./face-detection-0207/template_experimental.yaml) | 1 | diff --git a/external/mmdetection/configs/face-detection/tools/test_out_to_wider_predictions.py b/external/mmdetection/configs/face-detection/tools/test_out_to_wider_predictions.py new file mode 100644 index 00000000000..9a7055d7819 --- /dev/null +++ b/external/mmdetection/configs/face-detection/tools/test_out_to_wider_predictions.py @@ -0,0 +1,41 @@ +# Copyright (C) 2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +""" This script converts output of test.py (mmdetection) to a set of files +that can be passed to official WiderFace evaluation procedure.""" + +import argparse + +from mmcv import DictAction +from ote.datasets.face_detection.wider_face.convert_predictions import convert_to_wider + + +def parse_args(): + """ Parses input arguments. """ + + parser = argparse.ArgumentParser( + description='This script converts output of test.py (mmdetection) to ' + 'a set of files that can be passed to official WiderFace ' + 'evaluation procedure.') + parser.add_argument('config', help='test config file path') + parser.add_argument('input', help='output result file from test.py') + parser.add_argument('out_folder', help='folder where to store WiderFace ' + 'evaluation-friendly output') + parser.add_argument('--update_config', nargs='+', action=DictAction, + help='Update configuration file by parameters specified here.') + args = parser.parse_args() + return args + + +convert_to_wider(**vars(parse_args())) diff --git a/external/mmdetection/configs/face-detection/tools/wider_custom_eval.py b/external/mmdetection/configs/face-detection/tools/wider_custom_eval.py new file mode 100644 index 00000000000..ec1fda1ffca --- /dev/null +++ b/external/mmdetection/configs/face-detection/tools/wider_custom_eval.py @@ -0,0 +1,38 @@ +# Copyright (C) 2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +""" This script computes AveragePrecision (VOC) for faces in specific size ranges. """ + +from argparse import ArgumentParser + +from mmcv import DictAction +from ote.metrics.face_detection.custom_voc_ap_eval import custom_voc_ap_evaluation + + +def parse_args(): + """ Main function. """ + + parser = ArgumentParser(description='VOC Evaluation') + parser.add_argument('config', help='config file path') + parser.add_argument('input', help='output result file from test.py') + parser.add_argument('--imsize', nargs=2, type=int, default=(1024, 1024), + help='Image resolution. Used for filtering.') + parser.add_argument('--iou-thr', type=float, default=0.5, help='IoU threshold for evaluation') + parser.add_argument('--out', help='A path to file where metrics values will be saved (*.json).') + parser.add_argument('--update_config', nargs='+', action=DictAction, + help='Update configuration file by parameters specified here.') + return parser.parse_args() + + +custom_voc_ap_evaluation(**vars(parse_args())) diff --git a/external/mmdetection/configs/face-detection/tools/wider_face_eval.py b/external/mmdetection/configs/face-detection/tools/wider_face_eval.py new file mode 100644 index 00000000000..4dc2a12c890 --- /dev/null +++ b/external/mmdetection/configs/face-detection/tools/wider_face_eval.py @@ -0,0 +1,31 @@ +# Copyright (C) 2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + + +import argparse + +from ote.metrics.face_detection.wider_face.wider_face_eval import wider_face_evaluation + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('-p', '--pred', required=True) + parser.add_argument('-g', '--gt', required=True) + parser.add_argument('--out') + + return parse_args() + + +args = parse_args() +wider_face_evaluation(args.pred, args.gt, args.out) diff --git a/external/mmdetection/configs/face-detection/tools/wider_to_coco.py b/external/mmdetection/configs/face-detection/tools/wider_to_coco.py new file mode 100644 index 00000000000..3dca7fb2ab3 --- /dev/null +++ b/external/mmdetection/configs/face-detection/tools/wider_to_coco.py @@ -0,0 +1,39 @@ +# Copyright (C) 2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +""" Converts WiderFace annotation to COCO format. """ + +import argparse + +from ote.datasets.face_detection.wider_face.convert_annotation import convert_to_coco + + +def parse_args(): + """ Parses input arguments. """ + + parser = argparse.ArgumentParser(description='Convert dataset') + parser.add_argument('input_annotation', + help="Path to annotation file like wider_face_train_bbx_gt.txt") + parser.add_argument('images_dir', + help="Path to folder with images like WIDER_train/images") + parser.add_argument('output_annotation', help="Path to output json file") + parser.add_argument('--with_landmarks', action='store_true', + help="Whether to read landmarks") + + return parser.parse_args() + + +args = parse_args() +convert_to_coco(args.input_annotation, args.images_dir, + args.output_annotation, args.with_landmarks) diff --git a/external/mmdetection/configs/horizontal-text-detection/datasets.md b/external/mmdetection/configs/horizontal-text-detection/datasets.md new file mode 100644 index 00000000000..3725620c352 --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/datasets.md @@ -0,0 +1,61 @@ +## Prepare datasets + +### 1. Download datasets + +To be able to train networks and/or get quality metrics for pre-trained ones, +it's necessary to download at least one dataset from following resources. +* [ICDAR2013 (Focused Scene Text)](https://rrc.cvc.uab.es/?ch=2) - test part is used to get quality metric. +* [ICDAR2015 (Incidental Scene Text)](https://rrc.cvc.uab.es/?ch=4) +* [ICDAR2017 (MLT)](https://rrc.cvc.uab.es/?ch=8) +* [ICDAR2019 (MLT)](https://rrc.cvc.uab.es/?ch=15) +* [ICDAR2019 (ART)](https://rrc.cvc.uab.es/?ch=14) +* [MSRA-TD500](http://www.iapr-tc11.org/mediawiki/index.php/MSRA_Text_Detection_500_Database_(MSRA-TD500)) +* [COCO-Text](https://bgshih.github.io/cocotext/) + +### 2. Convert datasets + +Extract downloaded datasets in `${DATA_DIR}/text-dataset` folder. + +```bash +export DATA_DIR=${WORK_DIR}/data +``` + +Convert it to format that is used internally and split to the train and test part. + +* Training annotation +```bash +python ./configs/ote/horizontal-text-detection/tools/create_dataset.py \ + --config ./configs/ote/horizontal-text-detection/tools/datasets/dataset_train.json \ + --output ${DATA_DIR}/text-dataset/IC13TRAIN_IC15_IC17_IC19_MSRATD500_COCOTEXT.json \ + --root ${DATA_DIR}/text-dataset/ +export TRAIN_ANN_FILE=${DATA_DIR}/text-dataset/IC13TRAIN_IC15_IC17_IC19_MSRATD500_COCOTEXT.json +export TRAIN_IMG_ROOT=${DATA_DIR}/text-dataset +``` +* Testing annotation +```bash +python ./configs/ote/horizontal-text-detection/tools/create_dataset.py \ + --config ./configs/ote/horizontal-text-detection/tools/datasets/dataset_test.json \ + --output ${DATA_DIR}/text-dataset/IC13TEST.json \ + --root ${DATA_DIR}/text-dataset/ +export VAL_ANN_FILE=${DATA_DIR}/text-dataset/IC13TEST.json +export VAL_IMG_ROOT=${DATA_DIR}/text-dataset +export TEST_ANN_FILE=${VAL_ANN_FILE} +export TEST_IMG_ROOT=${VAL_IMG_ROOT} +``` + +Examples of json file for train and test dataset configuration can be found in `horizontal-text-detection/datasets`. +So, if you would like not to use all datasets above, please change its content. + +The structure of the folder with datasets: +``` +${DATA_DIR}/text-dataset + ├── coco-text + ├── icdar2013 + ├── icdar2015 + ├── icdar2017 + ├── icdar2019_art + ├── icdar2019_mlt + ├── MSRA-TD500 + ├── IC13TRAIN_IC15_IC17_IC19_MSRATD500_COCOTEXT.json + └── IC13TEST.json +``` diff --git a/external/mmdetection/configs/horizontal-text-detection/horizontal-text-detection-0001/compression_config.json b/external/mmdetection/configs/horizontal-text-detection/horizontal-text-detection-0001/compression_config.json new file mode 100755 index 00000000000..0639ace0c8e --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/horizontal-text-detection-0001/compression_config.json @@ -0,0 +1,41 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [1, 3, 704, 704] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0001 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} + diff --git a/external/mmdetection/configs/horizontal-text-detection/horizontal-text-detection-0001/model.py b/external/mmdetection/configs/horizontal-text-detection/horizontal-text-detection-0001/model.py new file mode 100644 index 00000000000..289ee50ee51 --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/horizontal-text-detection-0001/model.py @@ -0,0 +1,150 @@ +# model settings +model = dict( + type='FCOS', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=dict( + type='FPN', + in_channels=[24, 32, 96, 320], + out_channels=32, + start_level=1, + add_extra_convs=True, + extra_convs_on_inputs=False, # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='FCOSHead', + num_classes=1, + in_channels=32, + stacked_convs=4, + feat_channels=32, + strides=[8, 16, 32, 64, 128], + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.25, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)) +evaluation = dict(interval=1, metric=['bbox', 'f1'], score_thr=0.25) +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/text-dataset/' +img_norm_cfg = dict( + mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict( + type='Resize', + img_scale=[(704, 704), (844, 704), (704, 844), (564, 704), (704, 564)], + multiscale_mode='value', + keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(704, 704), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=8, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=1, + dataset=dict( + type=dataset_type, + classes=('text',), + ann_file=data_root + 'IC13TRAIN_IC15_IC17_IC19_MSRATD500_COCOTEXT.json', + img_prefix=data_root, + pipeline=train_pipeline), + ), + val=dict( + type=dataset_type, + classes=('text',), + ann_file=data_root + 'IC13TEST.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('text',), + ann_file=data_root + 'IC13TEST.json', + img_prefix=data_root, + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict( + type='SGD', + lr=0.01, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='constant', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[14, 22]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=50, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 25 +device_ids = range(4) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/horizontal-text-detection' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/horizontal-text-detection/readme.md b/external/mmdetection/configs/horizontal-text-detection/readme.md new file mode 100644 index 00000000000..74d176c3e4d --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/readme.md @@ -0,0 +1,5 @@ +# Horizontal Text Detection + +| Model Name | Complexity (GFLOPs) | Size (Mp) | F1-score | precision / recall | Links | GPU_NUM | +| --------------------------- | ------------------- | --------- | ------- | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- | +| horizontal-text-detection-0001 | 7.72 | 2.26 | 88.45% | 90.61% / 86.39% | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/horizontal-text-detection-0001.pth) | 2 | diff --git a/external/mmdetection/configs/horizontal-text-detection/tools/create_dataset.py b/external/mmdetection/configs/horizontal-text-detection/tools/create_dataset.py new file mode 100644 index 00000000000..a9dc966e6b1 --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/tools/create_dataset.py @@ -0,0 +1,71 @@ +""" + Copyright (c) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import argparse +import json +import logging +import os + +from ote.datasets.text_spotting import TextOnlyCocoAnnotation, str_to_class + + +def parse_args(): + """ Parses input arguments. """ + + args = argparse.ArgumentParser() + args.add_argument('--config', help='Path to dataset configuration file (json).', + required=True) + args.add_argument('--root', help='Root data dir.', + required=True) + args.add_argument('--output', help='Path where to save annotation (json).', + required=True) + args.add_argument('--visualize', action='store_true', help='Visualize annotation.') + args.add_argument('--shuffle', action='store_true', help='Shuffle annotation before visualization.') + args.add_argument('--delay', type=int, default=1) + return args.parse_args() + + +def main(): + """ Loads configuration file and creates dataset. """ + + logging.basicConfig(level=logging.INFO) + args = parse_args() + with open(args.config) as file: + config = json.load(file) + + assert isinstance(config, list) + ann = TextOnlyCocoAnnotation() + for dataset in config: + logging.info(f'Parsing {dataset["name"]}...') + assert isinstance(dataset, dict) + if os.path.islink(args.root): + dataset['kwargs']['root'] = os.readlink(args.root) + else: + dataset['kwargs']['root'] = os.path.abspath(args.root) + ann += str_to_class[dataset['name']](**dataset['kwargs'])() + logging.info(f'Parsing {dataset["name"]} has been completed.') + + logging.info(f'Writing annotation to {args.output}...') + ann.write(args.output) + logging.info(f'Writing annotation to {args.output} has been completed.') + + ann = TextOnlyCocoAnnotation(args.output, os.path.dirname(args.output)) + if args.visualize: + ann.visualize(put_text=True, imshow_delay=args.delay, shuffle=args.shuffle) + + +if __name__ == '__main__': + main() diff --git a/external/mmdetection/configs/horizontal-text-detection/tools/datasets/dataset_test.json b/external/mmdetection/configs/horizontal-text-detection/tools/datasets/dataset_test.json new file mode 100644 index 00000000000..78020b6c2c8 --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/tools/datasets/dataset_test.json @@ -0,0 +1,10 @@ +[ + { + "name": "ICDAR2013DatasetConverter", + "kwargs": { + "images_folder": "icdar2013/Challenge2_Test_Task12_Images", + "annotations_folder": "icdar2013/Challenge2_Test_Task1_GT", + "is_train": false + } + } +] diff --git a/external/mmdetection/configs/horizontal-text-detection/tools/datasets/dataset_train.json b/external/mmdetection/configs/horizontal-text-detection/tools/datasets/dataset_train.json new file mode 100644 index 00000000000..60409a02ace --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/tools/datasets/dataset_train.json @@ -0,0 +1,75 @@ +[ + { + "name": "ICDAR2013DatasetConverter", + "kwargs": { + "images_folder": "icdar2013/Challenge2_Training_Task12_Images", + "annotations_folder": "icdar2013/Challenge2_Training_Task1_GT", + "is_train": true + } + }, + { + "name": "ICDAR2015DatasetConverter", + "kwargs": { + "images_folder": "icdar2015/ch4_training_images", + "annotations_folder": "icdar2015/ch4_training_localization_transcription_gt", + "is_train": true + } + }, + { + "name": "ICDAR2015DatasetConverter", + "kwargs": { + "images_folder": "icdar2015/ch4_test_images", + "annotations_folder": "icdar2015/ch4_test_localization_transcription_gt", + "is_train": false + } + }, + { + "name": "ICDAR2017MLTDatasetConverter", + "kwargs": { + "folder": "icdar2017", + "subset": "train", + "is_latin_required": true + } + }, + { + "name": "ICDAR2017MLTDatasetConverter", + "kwargs": { + "folder": "icdar2017", + "subset": "val", + "is_latin_required": true + } + }, + { + "name": "ICDAR2019MLTDatasetConverter", + "kwargs": { + "folder": "icdar2019_mlt", + "is_latin_required": true + } + }, + { + "name": "ICDAR2019ARTDatasetConverter", + "kwargs": { + "folder": "icdar2019_art", + "is_latin_required": false + } + }, + { + "name": "MSRATD500DatasetConverter", + "kwargs": { + "folder": "MSRA-TD500/train" + } + }, + { + "name": "MSRATD500DatasetConverter", + "kwargs": { + "folder": "MSRA-TD500/test" + } + }, + { + "name": "COCOTextDatasetConverter", + "kwargs": { + "path": "coco-text/cocotext.v2.json", + "sets": ["train", "val"] + } + } +] diff --git a/external/mmdetection/configs/horizontal-text-detection/tools/draw_recall_graph.py b/external/mmdetection/configs/horizontal-text-detection/tools/draw_recall_graph.py new file mode 100644 index 00000000000..fba2efed71c --- /dev/null +++ b/external/mmdetection/configs/horizontal-text-detection/tools/draw_recall_graph.py @@ -0,0 +1,85 @@ +# Copyright (C) 2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +""" This script draws a graph of the detected words number (recall) + depending on their width. It helps to see the detection quality of the + small, normal or large inscriptions. Also for your convenience you may + visualize the detections straight away.""" + +import argparse +from os.path import exists +import subprocess # nosec + +import mmcv + +from mmdet.datasets import build_dataset # pylint: disable=import-error +from mmdet.core.evaluation.text_evaluation import text_eval # pylint: disable=import-error + + +def parse_args(): + """ Parses input arguments. """ + parser = argparse.ArgumentParser( + description='This script draws a histogram of the detected words ' + 'number (recall) depending on their width. It helps to ' + 'see the detection quality of the small, normal or large ' + 'inscriptions. Also for your convenience you may ' + 'visualize the detections straight away.') + parser.add_argument('config', help='test config file path') + parser.add_argument('snapshot', help='path to snapshot to be tested') + parser.add_argument('--draw_graph', action='store_true', help='draw histogram of recall') + parser.add_argument('--visualize', action='store_true', help='show detection result on images') + args = parser.parse_args() + return args + + +def main(): + """ Main function. """ + args = parse_args() + + detection_file = 'horizontal_text_detection' + if not exists(f'{detection_file}.bbox.json'): + subprocess.run( + f'python ../../../../../external/mmdetection/tools/test.py' + f' {args.config} {args.snapshot}' + f' --options jsonfile_prefix={detection_file}' + f' --format-only', + check=True, shell=True + ) + + cfg = mmcv.Config.fromfile(args.config) + dataset = build_dataset(cfg.data.test) + + results = mmcv.load(f'{detection_file}.bbox.json') + coco = dataset.coco + coco_dets = coco.loadRes(results) + predictions = coco_dets.imgToAnns + gt_annotations = coco.imgToAnns + + if args.visualize: + img_paths = [dataset.img_prefix + image['file_name'] + for image in coco_dets.dataset['images']] + else: + img_paths = None + + recall, precision, hmean, _ = text_eval( + predictions, gt_annotations, + cfg.test_cfg.score_thr, + images=img_paths, + show_recall_graph=args.draw_graph) + print('Text detection recall={:.4f} precision={:.4f} hmean={:.4f}'. + format(recall, precision, hmean)) + + +if __name__ == '__main__': + main() diff --git a/external/mmdetection/configs/person-detection/person-detection-0200/accuracy-check.yml b/external/mmdetection/configs/person-detection/person-detection-0200/accuracy-check.yml new file mode 100644 index 00000000000..cb6ed9a0d0b --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0200/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: person-detection-0200 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged_person + preprocessing: + - type: resize + dst_width: 256 + dst_height: 256 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/person-detection/person-detection-0200/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/person-detection/person-detection-0200/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..3bbde23799d --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0200/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: person-detection-0200 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged_person + preprocessing: + - type: resize + dst_width: 256 + dst_height: 256 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/person-detection/person-detection-0200/compression_config.json b/external/mmdetection/configs/person-detection/person-detection-0200/compression_config.json new file mode 100644 index 00000000000..1fc6868979d --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0200/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 256, + 256 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/person-detection/person-detection-0200/model.py b/external/mmdetection/configs/person-detection/person-detection-0200/model.py new file mode 100644 index 00000000000..b5ec4926c0a --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0200/model.py @@ -0,0 +1,161 @@ +# model settings +input_size = 256 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.015411783166343854, 0.033018232306549156, 0.04467156688464953, + 0.0610697815328886]], + [image_width * x for x in + [0.0789599954420517, 0.10113984043326349, 0.12805187473050397, 0.16198319380154758, + 0.21636496806213493]], + + ], + heights=[ + [image_height * x for x in + [0.05032631418898226, 0.10070800135152037, 0.15806180366055939, + 0.22343401646383804]], + [image_height * x for x in + [0.300881401352503, 0.393181898580379, 0.4998807213337051, 0.6386035764261081, + 0.8363451552091518]], + + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=122, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_train.json', + min_size=20, + img_prefix=data_root + 'train', + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-detection-0200' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-detection/person-detection-0201/accuracy-check.yml b/external/mmdetection/configs/person-detection/person-detection-0201/accuracy-check.yml new file mode 100644 index 00000000000..f56c8731e5e --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0201/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: person-detection-0201 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged_person + preprocessing: + - type: resize + dst_width: 384 + dst_height: 384 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/person-detection/person-detection-0201/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/person-detection/person-detection-0201/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..2c4911d0a89 --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0201/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: person-detection-0201 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged_person + preprocessing: + - type: resize + dst_width: 384 + dst_height: 384 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/person-detection/person-detection-0201/compression_config.json b/external/mmdetection/configs/person-detection/person-detection-0201/compression_config.json new file mode 100644 index 00000000000..3d5064b6cc0 --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0201/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 384, + 384 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/person-detection/person-detection-0201/model.py b/external/mmdetection/configs/person-detection/person-detection-0201/model.py new file mode 100644 index 00000000000..4e25a54727c --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0201/model.py @@ -0,0 +1,161 @@ +# model settings +input_size = 384 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.015411783166343854, 0.033018232306549156, 0.04467156688464953, + 0.0610697815328886]], + [image_width * x for x in + [0.0789599954420517, 0.10113984043326349, 0.12805187473050397, 0.16198319380154758, + 0.21636496806213493]], + + ], + heights=[ + [image_height * x for x in + [0.05032631418898226, 0.10070800135152037, 0.15806180366055939, + 0.22343401646383804]], + [image_height * x for x in + [0.300881401352503, 0.393181898580379, 0.4998807213337051, 0.6386035764261081, + 0.8363451552091518]], + + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=84, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_train.json', + min_size=20, + img_prefix=data_root + 'train', + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-detection-0201' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-detection/person-detection-0202/accuracy-check.yml b/external/mmdetection/configs/person-detection/person-detection-0202/accuracy-check.yml new file mode 100644 index 00000000000..6539bd8773c --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0202/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: person-detection-0202 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged_person + preprocessing: + - type: resize + dst_width: 512 + dst_height: 512 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/person-detection/person-detection-0202/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/person-detection/person-detection-0202/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..245ac2712b2 --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0202/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: person-detection-0202 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged_person + preprocessing: + - type: resize + dst_width: 512 + dst_height: 512 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/person-detection/person-detection-0202/compression_config.json b/external/mmdetection/configs/person-detection/person-detection-0202/compression_config.json new file mode 100644 index 00000000000..5a1ceafc2df --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0202/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 512, + 512 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/person-detection/person-detection-0202/model.py b/external/mmdetection/configs/person-detection/person-detection-0202/model.py new file mode 100644 index 00000000000..735fb336eeb --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0202/model.py @@ -0,0 +1,161 @@ +# model settings +input_size = 512 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.015411783166343854, 0.033018232306549156, 0.04467156688464953, + 0.0610697815328886]], + [image_width * x for x in + [0.0789599954420517, 0.10113984043326349, 0.12805187473050397, 0.16198319380154758, + 0.21636496806213493]], + + ], + heights=[ + [image_height * x for x in + [0.05032631418898226, 0.10070800135152037, 0.15806180366055939, + 0.22343401646383804]], + [image_height * x for x in + [0.300881401352503, 0.393181898580379, 0.4998807213337051, 0.6386035764261081, + 0.8363451552091518]], + + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=30, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_train.json', + min_size=20, + img_prefix=data_root + 'train', + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-detection-0202' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-detection/person-detection-0203/compression_config.json b/external/mmdetection/configs/person-detection/person-detection-0203/compression_config.json new file mode 100755 index 00000000000..8ff1f9b4ba6 --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0203/compression_config.json @@ -0,0 +1,49 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 480, + 864 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 1, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} + diff --git a/external/mmdetection/configs/person-detection/person-detection-0203/model.py b/external/mmdetection/configs/person-detection/person-detection-0203/model.py new file mode 100644 index 00000000000..b0257dd96f6 --- /dev/null +++ b/external/mmdetection/configs/person-detection/person-detection-0203/model.py @@ -0,0 +1,157 @@ +# model settings +model = dict( + type='ATSS', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=dict( + type='FPN', + in_channels=[24, 32, 96, 320], + out_channels=32, + start_level=1, + add_extra_convs=True, + extra_convs_on_inputs=False, + num_outs=5), + bbox_head=dict( + type='ATSSHead', + num_classes=1, + in_channels=32, + stacked_convs=4, + feat_channels=32, anchor_generator=dict( + type='AnchorGenerator', + ratios=[0.5, 1.0, 2.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict( + mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='Expand', ratio_range=(1, 3)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict( + type='Resize', + img_scale=[(864, 480), (864, 640)], + keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(864, 480), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=14, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=1, + dataset=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_train.json', + img_prefix=data_root + 'train', + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('person',), + ann_file=data_root + 'annotation_person_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict( + type='SGD', + lr=0.025, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='constant', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[10, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-detection-0203' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-detection/readme.md b/external/mmdetection/configs/person-detection/readme.md new file mode 100644 index 00000000000..62a0d29e1a5 --- /dev/null +++ b/external/mmdetection/configs/person-detection/readme.md @@ -0,0 +1,8 @@ +# Person Detection + +| Model Name | Complexity (GFLOPs) | Size (Mp) | AP @ [IoU=0.50:0.95] (%) | Links | GPU_NUM | +| --- | --- | --- | --- | --- | --- | +| person-detection-0200 | 0.82 | 1.83 | 24.4 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/person-detection-0200-1.pth) | 2 | +| person-detection-0201 | 1.84 | 1.83 | 29.9 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/person-detection-0201-1.pth) | 4 | +| person-detection-0202 | 3.28 | 1.83 | 32.8 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/person-detection-0202-1.pth) | 2 | +| person-detection-0203 | 6.74 | 1.95 | 40.8 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/person-detection-0203.pth) | 2 | diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/accuracy-check.yml b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/accuracy-check.yml new file mode 100755 index 00000000000..45530e27fa9 --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: person-vehicle-bike-detection-2000 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged + preprocessing: + - type: resize + dst_width: 256 + dst_height: 256 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..76c361a06e8 --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: person-vehicle-bike-detection-2000 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged + preprocessing: + - type: resize + dst_width: 256 + dst_height: 256 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/compression_config.json b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/compression_config.json new file mode 100644 index 00000000000..1fc6868979d --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 256, + 256 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/model.py b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/model.py new file mode 100644 index 00000000000..fb3a0f0664e --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2000/model.py @@ -0,0 +1,159 @@ +# model settings +input_size = 256 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=3, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.027985084698552577, 0.05080701904477674, 0.05982521591620597, + 0.09207979657583232]], + [image_width * x for x in + [0.20259559591239545, 0.12732159067712165, 0.1934764607279801, + 0.35789819765821385, 0.587237190090815]], + ], + heights=[ + [image_height * x for x in + [0.0479932750007942, 0.11405624363135988, 0.20898520700595447, + 0.3335612473329943]], + [image_height * x for x in + [0.1674597285977332, 0.4942406505865888, 0.7431758023015786, 0.41062433524702613, + 0.5719883460663506]], + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=192, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_train.json', + img_prefix=data_root + 'train', + min_size=20, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-vehicle-bike-detection-2000' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/accuracy-check.yml b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/accuracy-check.yml new file mode 100755 index 00000000000..f57547cf6bd --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: person-vehicle-bike-detection-2001 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged + preprocessing: + - type: resize + dst_width: 384 + dst_height: 384 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..a371f10dd0b --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: person-vehicle-bike-detection-2001 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged + preprocessing: + - type: resize + dst_width: 384 + dst_height: 384 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/compression_config.json b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/compression_config.json new file mode 100644 index 00000000000..3d5064b6cc0 --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 384, + 384 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/model.py b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/model.py new file mode 100644 index 00000000000..697e0a9924c --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2001/model.py @@ -0,0 +1,159 @@ +# model settings +input_size = 384 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=3, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.027985084698552577, 0.05080701904477674, 0.05982521591620597, + 0.09207979657583232]], + [image_width * x for x in + [0.20259559591239545, 0.12732159067712165, 0.1934764607279801, + 0.35789819765821385, 0.587237190090815]], + ], + heights=[ + [image_height * x for x in + [0.0479932750007942, 0.11405624363135988, 0.20898520700595447, + 0.3335612473329943]], + [image_height * x for x in + [0.1674597285977332, 0.4942406505865888, 0.7431758023015786, 0.41062433524702613, + 0.5719883460663506]], + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=54, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_train.json', + img_prefix=data_root + 'train', + min_size=20, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-vehicle-bike-detection-2001' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/accuracy-check.yml b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/accuracy-check.yml new file mode 100755 index 00000000000..540cdebda78 --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: person-vehicle-bike-detection-2002 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged + preprocessing: + - type: resize + dst_width: 512 + dst_height: 512 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..68d1b3b2d4b --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: person-vehicle-bike-detection-2000 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged + preprocessing: + - type: resize + dst_width: 512 + dst_height: 512 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/compression_config.json b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/compression_config.json new file mode 100644 index 00000000000..5a1ceafc2df --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 512, + 512 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/model.py b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/model.py new file mode 100644 index 00000000000..270b930139b --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2002/model.py @@ -0,0 +1,159 @@ +# model settings +input_size = 512 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=3, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.027985084698552577, 0.05080701904477674, 0.05982521591620597, + 0.09207979657583232]], + [image_width * x for x in + [0.20259559591239545, 0.12732159067712165, 0.1934764607279801, + 0.35789819765821385, 0.587237190090815]], + ], + heights=[ + [image_height * x for x in + [0.0479932750007942, 0.11405624363135988, 0.20898520700595447, + 0.3335612473329943]], + [image_height * x for x in + [0.1674597285977332, 0.4942406505865888, 0.7431758023015786, 0.41062433524702613, + 0.5719883460663506]], + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=30, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_train.json', + img_prefix=data_root + 'train', + min_size=20, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-vehicle-bike-detection-2002' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2003/model.py b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2003/model.py new file mode 100644 index 00000000000..28f1c1a0d8f --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2003/model.py @@ -0,0 +1,158 @@ +# model settings +model = dict( + type='ATSS', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=dict( + type='FPN', + in_channels=[24, 32, 96, 320], + out_channels=32, + start_level=1, + add_extra_convs=True, + extra_convs_on_inputs=False, + num_outs=5), + bbox_head=dict( + type='ATSSHead', + num_classes=3, + in_channels=32, + stacked_convs=4, + feat_channels=32, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[0.5, 1.0, 2.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict( + mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='Expand', ratio_range=(1, 3)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict( + type='Resize', + img_scale=[(864, 480), (864, 640)], + keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(864, 480), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=14, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=1, + dataset=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_train.json', + img_prefix=data_root + 'train', + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict( + type='SGD', + lr=0.025, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='constant', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[10, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-vehicle-bike-detection-2003' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2004/model.py b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2004/model.py new file mode 100644 index 00000000000..ab7662b7cc5 --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/person-vehicle-bike-detection-2004/model.py @@ -0,0 +1,158 @@ +# model settings +model = dict( + type='ATSS', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=dict( + type='FPN', + in_channels=[24, 32, 96, 320], + out_channels=32, + start_level=1, + add_extra_convs=True, + extra_convs_on_inputs=False, + num_outs=5), + bbox_head=dict( + type='ATSSHead', + num_classes=3, + in_channels=32, + stacked_convs=4, + feat_channels=32, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[0.5, 1.0, 2.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# dataset settings +dataset_type = 'CocoDataset' +data_root = '../../data/airport/' +img_norm_cfg = dict( + mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='Expand', ratio_range=(1, 3)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict( + type='Resize', + img_scale=[(448, 256), (448, 320)], + keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(448, 256), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=54, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=1, + dataset=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_train.json', + img_prefix=data_root + 'train', + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle', 'person', 'non-vehicle'), + ann_file=data_root + 'annotation_example_val.json', + img_prefix=data_root + 'val', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict( + type='SGD', + lr=0.2, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='constant', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[10, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=10, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/person-vehicle-bike-detection-2004' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/person-vehicle-bike-detection/readme.md b/external/mmdetection/configs/person-vehicle-bike-detection/readme.md new file mode 100644 index 00000000000..fa79b2941ea --- /dev/null +++ b/external/mmdetection/configs/person-vehicle-bike-detection/readme.md @@ -0,0 +1,11 @@ +# Person-Vehicle-Bike Detector + +The crossroad-detection network model provides detection of three class objects: vehicle, pedestrian, non-vehicle (like bikes). This detector was trained on the data from crossroad cameras. + +| Model Name | Complexity (GFLOPs) | Size (Mp) | AP @ [IoU=0.50:0.95] (%) | Links | GPU_NUM | +| --- | --- | --- | --- | --- | --- | +| person-vehicle-bike-detection-2000 | 0.82 | 1.84 | 16.5 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/vehicle-person-bike-detection-2000-1.pth) | 4 | +| person-vehicle-bike-detection-2001 | 1.86 | 1.84 | 22.6 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/vehicle-person-bike-detection-2001-1.pth) | 4 | +| person-vehicle-bike-detection-2002 | 3.30 | 1.84 | 24.8 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/vehicle-person-bike-detection-2002-1.pth) | 4 | +| person-vehicle-bike-detection-2003 | 6.78 | 1.95 | 33.6 | [snapshot](https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/vehicle-person-bike-detection-2003.pth) | 2 | +| person-vehicle-bike-detection-2004 | 1.88 | 1.95 | 27.4 | [snapshot](https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/object_detection/v2/vehicle-person-bike-detection-2004.pth) | 2 | diff --git a/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/coco_data_pipeline.py b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/coco_data_pipeline.py new file mode 100644 index 00000000000..4ea2f34695b --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/coco_data_pipeline.py @@ -0,0 +1,57 @@ +dataset_type = 'CocoDataset' +img_size = (1024, 1024) + +img_norm_cfg = dict( + mean=(103.53, 116.28, 123.675), std=(1.0, 1.0, 1.0), to_rgb=False) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True, + with_mask=True, poly2mask=False), + dict(type='Resize', img_scale=img_size, keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']) +] + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=img_size, + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] + +data = dict(samples_per_gpu=4, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + adaptive_repeat_times=True, + times=1, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline), + test=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline)) \ No newline at end of file diff --git a/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/compression_config.json b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/compression_config.json new file mode 100644 index 00000000000..c41f7a83740 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/compression_config.json @@ -0,0 +1,43 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 1024, 1024] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 1000 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 1000 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/hpo_config.yaml b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/hpo_config.yaml new file mode 100644 index 00000000000..f21916e091c --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 2 + - 4 + - 2 diff --git a/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/model.py b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/model.py new file mode 100644 index 00000000000..b9faa07b339 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/model.py @@ -0,0 +1,160 @@ +_base_ = [ + './coco_data_pipeline.py' +] + +model = dict( + type='MaskRCNN', + backbone=dict( + type='efficientnet_b2b', + out_indices=(2, 3, 4, 5), + frozen_stages=-1, + pretrained=True, + activation_cfg=dict(type='torch_swish'), + norm_cfg=dict(type='BN', requires_grad=True)), + neck=dict( + type='FPN', + in_channels=[24, 48, 120, 352], + out_channels=80, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=80, + feat_channels=80, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=80, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=80, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=80, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='FCNMaskHead', + num_convs=4, + in_channels=80, + conv_out_channels=80, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))), + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_across_levels=False, + nms_pre=2000, + nms_post=1000, + max_num=1000, + nms_thr=0.8, + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_across_levels=False, + nms_pre=800, + nms_post=500, + max_num=500, + nms_thr=0.8, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.7), + max_per_img=500, + mask_thr_binary=0.5))) + +cudnn_benchmark = True +evaluation = dict(interval=1, metric='mAP', save_best='mAP', iou_thr=[0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9, 0.95]) +optimizer = dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=None) +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=5, + iteration_patience=300, + interval=1, + min_lr=0.000001, + warmup='linear', + warmup_iters=200, + warmup_ratio=0.3333333333333333 +) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +checkpoint_config = dict(interval=5) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +dist_params = dict(backend='nccl') +log_level = 'INFO' +load_from = 'https://storage.openvinotoolkit.org/repositories/openvino_training_extensions/models/instance_segmentation/v2/efficientnet_b2b-mask_rcnn-576x576.pth' +resume_from = None +workflow = [('train', 1)] +work_dir = 'output' +custom_hooks = [ + dict(type='EarlyStoppingHook', patience=10, metric='mAP', + interval=1, priority=75, iteration_patience=0), +] +fp16 = dict(loss_scale=512.) diff --git a/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/template.yaml b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/template.yaml new file mode 100644 index 00000000000..22522e13c58 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/efficientnetb2b_maskrcnn/template.yaml @@ -0,0 +1,52 @@ +# Description. +model_template_id: Custom_Rotated_Detection_via_Instance_Segmentation_MaskRCNN_EfficientNetB2B +name: MaskRCNN-EfficientNetB2B +task_type: ROTATED_DETECTION +task_family: VISION +instantiation: "CLASS" +summary: Rotated object detection models detect objects as rotated bounding boxes. This model is based on MaskRCNN-EfficientNetB2B which is faster in training and inference but less accurate. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 4 + learning_rate: + default_value: 0.015 + learning_rate_warmup_iters: + default_value: 200 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# Stats. +gigaflops: 68.48 +size: 13.27 diff --git a/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/coco_data_pipeline.py b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/coco_data_pipeline.py new file mode 100644 index 00000000000..084c5c6e5f6 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/coco_data_pipeline.py @@ -0,0 +1,55 @@ +dataset_type = 'CocoDataset' +img_size = (1344, 800) + +img_norm_cfg = dict(mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True, + with_mask=True, poly2mask=False), + dict(type='Resize', img_scale=img_size, keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']) +] + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='MultiScaleFlipAug', + img_scale=img_size, + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] + +data = dict(samples_per_gpu=4, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + adaptive_repeat_times=True, + times=1, + dataset=dict( + type=dataset_type, + ann_file='data/coco/annotations/instances_train2017.json', + img_prefix='data/coco/train2017', + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline), + test=dict( + type=dataset_type, + test_mode=True, + ann_file='data/coco/annotations/instances_val2017.json', + img_prefix='data/coco/val2017', + pipeline=test_pipeline)) diff --git a/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/compression_config.json b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/compression_config.json new file mode 100644 index 00000000000..533583e8352 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/compression_config.json @@ -0,0 +1,43 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "target_metric_name": "mAP", + "input_info": { + "sample_size": [1, 3, 1344, 800] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "lr": 0.0005 + }, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 1000 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 1000 + } + } + } + ], + "accuracy_aware_training": { + "mode": "early_exit", + "params": { + "maximal_absolute_accuracy_degradation": 0.01, + "maximal_total_epochs": 20 + } + } + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} diff --git a/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/hpo_config.yaml b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/hpo_config.yaml new file mode 100644 index 00000000000..f21916e091c --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/hpo_config.yaml @@ -0,0 +1,16 @@ +metric: mAP +search_algorithm: smbo +early_stop: None +hp_space: + learning_parameters.learning_rate: + param_type: quniform + range: + - 0.001 + - 0.1 + - 0.001 + learning_parameters.batch_size: + param_type: qloguniform + range: + - 2 + - 4 + - 2 diff --git a/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/model.py b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/model.py new file mode 100644 index 00000000000..f857a48bce6 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/model.py @@ -0,0 +1,177 @@ +_base_ = [ + './coco_data_pipeline.py' +] +model = dict( + type='MaskRCNN', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict(type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict(type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict(type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict(type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict(type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', + output_size=14, + sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='FCNMaskHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict(type='CrossEntropyLoss', + use_mask=True, + loss_weight=1.0))), + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_across_levels=False, + nms_pre=2000, + nms_post=1000, + max_num=1000, + nms_thr=0.7, + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=True, + ignore_iof_thr=-1, + gpu_assign_thr=300), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_across_levels=False, + nms_pre=1000, + nms_post=1000, + max_num=1000, + nms_thr=0.7, + max_per_img=1000, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict( + type='nms', iou_threshold=0.5, max_num=100), + max_per_img=100, + mask_thr_binary=0.5))) + +cudnn_benchmark = True +evaluation = dict(interval=1, metric='mAP', save_best='mAP', iou_thr=[0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9, 0.95]) +optimizer = dict( + type='SGD', + lr=0.01, + momentum=0.9, + weight_decay=0.0001) +optimizer_config = dict() + +lr_config = dict( + policy='ReduceLROnPlateau', + metric='mAP', + patience=5, + iteration_patience=300, + interval=1, + min_lr=0.000001, + warmup='linear', + warmup_iters=200, + warmup_ratio=1.0 / 3) + +checkpoint_config = dict(interval=5) +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook'), + ]) +runner = dict(type='EpochRunnerWithCancel', max_epochs=300) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'output' +# TODO[EUGENE]: UPLOAD TO openvinotoolkit storage repo +load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_fpn_mstrain-poly_3x_coco_20210524_201154-21b550bb.pth' +resume_from = None +workflow = [('train', 1)] +custom_hooks = [ + dict( + type='EarlyStoppingHook', + patience=10, + iteration_patience=0, + metric='mAP', + interval=1, + priority=75) +] diff --git a/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/template.yaml b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/template.yaml new file mode 100644 index 00000000000..2289612fb29 --- /dev/null +++ b/external/mmdetection/configs/rotated_detection/resnet50_maskrcnn/template.yaml @@ -0,0 +1,53 @@ +# Description. +model_template_id: Custom_Rotated_Detection_via_Instance_Segmentation_MaskRCNN_ResNet50 +name: MaskRCNN-ResNet50 +task_type: ROTATED_DETECTION +task_family: VISION +instantiation: "CLASS" +summary: Rotated object detection models detect objects as rotated bounding boxes. This model is based on MaskRCNN-ResNet50 which gives accurate predictions but slower during training and inference. +application: ~ + +# Algo backend. +framework: OTEDetection v2.9.1 + +# Task implementations. +entrypoints: + base: detection_tasks.apis.detection.OTEDetectionTrainingTask + openvino: detection_tasks.apis.detection.OpenVINODetectionTask + nncf: detection_tasks.apis.detection.OTEDetectionNNCFTask + +# Capabilities. +capabilities: + - compute_representations + +# Hyperparameters. +hyper_parameters: + base_path: ../../../../mmdetection/detection_tasks/apis/detection/configuration.yaml + parameter_overrides: + learning_parameters: + batch_size: + default_value: 4 + learning_rate: + default_value: 0.01 + learning_rate_warmup_iters: + default_value: 200 + num_iters: + default_value: 300 + nncf_optimization: + enable_quantization: + default_value: true + enable_pruning: + default_value: false + maximal_accuracy_degradation: + default_value: 1.0 + +# Training resources. +max_nodes: 1 +training_targets: + - GPU + - CPU + +# TODO[EUGENE]: WIP +# Stats. +gigaflops: 533.8 +size: 177.9 diff --git a/external/mmdetection/configs/vehicle-detection/datasets.md b/external/mmdetection/configs/vehicle-detection/datasets.md new file mode 100644 index 00000000000..bbfacd88ec3 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/datasets.md @@ -0,0 +1,18 @@ +## Prepare datasets + +### 1. Download datasets + +Collect or download images with vehicles presented on them. One can download MS-COCO dataset and remain images with cars only. +```bash +export DATA_DIR=${WORK_DIR}/data +wget http://images.cocodataset.org/zips/val2017.zip -P ${DATA_DIR}/ +wget http://images.cocodataset.org/zips/train2017.zip -P ${DATA_DIR}/ +wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip -P ${DATA_DIR}/ +unzip ${DATA_DIR}/val2017.zip -d ${DATA_DIR}/ +unzip ${DATA_DIR}/train2017.zip -d ${DATA_DIR}/ +unzip ${DATA_DIR}/annotations_trainval2017.zip -d ${DATA_DIR}/ +python tools/coco_filter.py ${DATA_DIR}/annotations/instances_train2017.json ${DATA_DIR}/annotations/instances_train2017car.json --filter car --remap +python tools/coco_filter.py ${DATA_DIR}/annotations/instances_val2017.json ${DATA_DIR}/annotations/instances_val2017car.json --filter car --remap +sed -i "s/car/vehicle/g" ${DATA_DIR}/annotations/instances_val2017car.json +sed -i "s/car/vehicle/g" ${DATA_DIR}/annotations/instances_train2017car.json +``` diff --git a/external/mmdetection/configs/vehicle-detection/readme.md b/external/mmdetection/configs/vehicle-detection/readme.md new file mode 100644 index 00000000000..6b8f4933772 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/readme.md @@ -0,0 +1,8 @@ +# Vehicle Detection + +| Model Name | Complexity (GFLOPs) | Size (Mp) | AP @ [IoU=0.50:0.95] (%) | Links | GPU_NUM | +| --- | --- | --- | --- | --- | --- | +| vehicle-detection-0200 | 0.82 | 1.83 | 25.4 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/vehicle-detection-0200-1.pth) | 4 | +| vehicle-detection-0201 | 1.84 | 1.83 | 32.3 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/vehicle-detection-0201-1.pth) | 4 | +| vehicle-detection-0202 | 3.28 | 1.83 | 36.9 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v2/vehicle-detection-0202-1.pth) | 4 | +| vehicle-detection-0203 | 112.34 | 24.11 | 43.5 | [snapshot](https://download.01.org/opencv/openvino_training_extensions/models/object_detection/v3/vehicle-detection-0203.pth) | 4 | diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/accuracy-check.yml b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/accuracy-check.yml new file mode 100755 index 00000000000..77cd1b77a08 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: vehicle-detection-0200 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged_vehicle + preprocessing: + - type: resize + dst_width: 256 + dst_height: 256 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..02662ee9b84 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: vehicle-detection-0200 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged_vehicle + preprocessing: + - type: resize + dst_width: 256 + dst_height: 256 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/compression_config.json b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/compression_config.json new file mode 100644 index 00000000000..1fc6868979d --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 256, + 256 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/model.py b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/model.py new file mode 100644 index 00000000000..1b8a3f9aac8 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0200/model.py @@ -0,0 +1,159 @@ +# model settings +input_size = 256 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.03190665436176343, 0.07246889234100704, 0.13534887659200423, + 0.15785373692633903]], + [image_width * x for x in + [0.29641301747833876, 0.3296121909277462, 0.2130097277660658, 0.45965227145427356, + 0.6790618020935402]], + + ], + heights=[ + [image_height * x for x in + [0.03836520511012714, 0.08658721963691468, 0.15106894690367778, + 0.30385265971706454]], + [image_height * x for x in + [0.2010092421878013, 0.4087630480186569, 0.6694307467997506, 0.4766551262641776, + 0.6573119829938249]], + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=185, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_train2017car.json', + img_prefix='data/train2017', + min_size=20, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/vehicle-detection-0200' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/accuracy-check.yml b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/accuracy-check.yml new file mode 100755 index 00000000000..a741fff0c32 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: vehicle-detection-0201 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged_vehicle + preprocessing: + - type: resize + dst_width: 384 + dst_height: 384 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..bc00261f42b --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: vehicle-detection-0201 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged_vehicle + preprocessing: + - type: resize + dst_width: 384 + dst_height: 384 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/compression_config.json b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/compression_config.json new file mode 100644 index 00000000000..3d5064b6cc0 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 384, + 384 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/model.py b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/model.py new file mode 100644 index 00000000000..46390b983ee --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0201/model.py @@ -0,0 +1,159 @@ +# model settings +input_size = 384 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.03190665436176343, 0.07246889234100704, 0.13534887659200423, + 0.15785373692633903]], + [image_width * x for x in + [0.29641301747833876, 0.3296121909277462, 0.2130097277660658, 0.45965227145427356, + 0.6790618020935402]], + + ], + heights=[ + [image_height * x for x in + [0.03836520511012714, 0.08658721963691468, 0.15106894690367778, + 0.30385265971706454]], + [image_height * x for x in + [0.2010092421878013, 0.4087630480186569, 0.6694307467997506, 0.4766551262641776, + 0.6573119829938249]], + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=82, + workers_per_gpu=4, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_train2017car.json', + img_prefix='data/train2017', + min_size=20, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/vehicle-detection-0201' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/accuracy-check.yml b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/accuracy-check.yml new file mode 100755 index 00000000000..cac3920e380 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/accuracy-check.yml @@ -0,0 +1,22 @@ +models: + - name: vehicle-detection-0202 + + launchers: + - framework: dlsdk + adapter: + type: ssd_onnx + bboxes_out: boxes + labels_out: labels + + datasets: + - name: crossroad_extra_untagged_vehicle + preprocessing: + - type: resize + dst_width: 512 + dst_height: 512 + postprocessing: + - type: resize_prediction_boxes + rescale: True + metrics: + - type: coco_orig_precision + include_boundaries: False diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/accuracy-check_alt-ssd-export.yml b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/accuracy-check_alt-ssd-export.yml new file mode 100644 index 00000000000..d25be745c37 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/accuracy-check_alt-ssd-export.yml @@ -0,0 +1,20 @@ +models: + - name: vehicle-detection-0202 + + launchers: + - framework: dlsdk + adapter: ssd + + datasets: + - name: crossroad_extra_untagged_vehicle + preprocessing: + - type: resize + dst_width: 512 + dst_height: 512 + postprocessing: + - type: resize_prediction_boxes + - type: clip_boxes + apply_to: prediction + metrics: + - type: coco_orig_precision + include_boundaries: false diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/compression_config.json b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/compression_config.json new file mode 100644 index 00000000000..5a1ceafc2df --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/compression_config.json @@ -0,0 +1,48 @@ +{ + "base": { + "find_unused_parameters": true, + "nncf_config": { + "input_info": { + "sample_size": [ + 1, + 3, + 512, + 512 + ] + }, + "compression": [], + "log_dir": "." + } + }, + "nncf_quantization": { + "optimizer": { + "type": "SGD", + "lr": 0.00005, + "momentum": 0.9, + "weight_decay": 0.0005 + }, + "lr_config": { + "_delete_": true, + "policy": "fixed" + }, + "total_epochs": 2, + "nncf_config": { + "compression": [ + { + "algorithm": "quantization", + "initializer": { + "range": { + "num_init_samples": 10 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 30 + } + } + } + ] + } + }, + "order_of_parts": [ + "nncf_quantization" + ] +} \ No newline at end of file diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/model.py b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/model.py new file mode 100644 index 00000000000..ed1648132d0 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0202/model.py @@ -0,0 +1,159 @@ +# model settings +input_size = 512 +image_width, image_height = input_size, input_size +width_mult = 1.0 +model = dict( + type='SingleStageDetector', + backbone=dict( + type='mobilenetv2_w1', + out_indices=(4, 5), + frozen_stages=-1, + norm_eval=False, + pretrained=True + ), + neck=None, + bbox_head=dict( + type='SSDHead', + num_classes=1, + in_channels=(int(width_mult * 96), int(width_mult * 320)), + anchor_generator=dict( + type='SSDAnchorGeneratorClustered', + strides=(16, 32), + widths=[ + [image_width * x for x in + [0.03190665436176343, 0.07246889234100704, 0.13534887659200423, + 0.15785373692633903]], + [image_width * x for x in + [0.29641301747833876, 0.3296121909277462, 0.2130097277660658, 0.45965227145427356, + 0.6790618020935402]], + + ], + heights=[ + [image_height * x for x in + [0.03836520511012714, 0.08658721963691468, 0.15106894690367778, + 0.30385265971706454]], + [image_height * x for x in + [0.2010092421878013, 0.4087630480186569, 0.6694307467997506, 0.4766551262641776, + 0.6573119829938249]], + ], + ), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.2, 0.2), ), + depthwise_heads=True, + depthwise_heads_activations='relu', + loss_balancing=True), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.4, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + smoothl1_beta=1., + use_giou=False, + use_focal=False, + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True +# dataset settings +dataset_type = 'CocoDataset' +img_norm_cfg = dict(mean=[0, 0, 0], std=[255, 255, 255], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.1), + dict(type='Resize', img_scale=(input_size, input_size), keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(input_size, input_size), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='Normalize', **img_norm_cfg), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']), + ]) +] +data = dict( + samples_per_gpu=30, + workers_per_gpu=3, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_train2017car.json', + img_prefix='data/train2017', + min_size=20, + pipeline=train_pipeline + ) + ), + val=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline)) +# optimizer +optimizer = dict(type='SGD', lr=0.05, momentum=0.9, weight_decay=0.0005) +optimizer_config = dict() +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=1200, + warmup_ratio=1.0 / 3, + step=[8, 15, 18]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 20 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = 'outputs/vehicle-detection-0202' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/external/mmdetection/configs/vehicle-detection/vehicle-detection-0203/model.py b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0203/model.py new file mode 100644 index 00000000000..da84f1d4ed3 --- /dev/null +++ b/external/mmdetection/configs/vehicle-detection/vehicle-detection-0203/model.py @@ -0,0 +1,261 @@ +model = dict( + type='CascadeRCNN', + pretrained='torchvision://resnet18', + backbone=dict( + type='ResNet', + depth=18, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[64, 128, 256, 512], + out_channels=64, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=64, + feat_channels=128, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict( + type='SmoothL1Loss', beta=0.1111111111111111, loss_weight=1.0)), + roi_head=dict( + type='CascadeRoIHead', + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=64, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=64, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=64, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=64, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ]), + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_across_levels=False, + nms_pre=2000, + nms_post=2000, + max_num=2000, + nms_thr=0.7, + min_bbox_size=0), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False) + ], + stage_loss_weights=[1, 0.5, 0.25]), + test_cfg=dict( + rpn=dict( + nms_across_levels=False, + nms_pre=1000, + nms_post=1000, + max_num=1000, + nms_thr=0.7, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, nms=dict(type='nms', iou_threshold=0.5), max_per_img=100))) +dataset_type = 'CocoDataset' +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', img_scale=(1333, 800), keep_ratio=False), + dict(type='RandomFlip', flip_ratio=0.5), + dict( + type='Normalize', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']) +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='MultiScaleFlipAug', + img_scale=(1344, 800), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=False), + dict(type='RandomFlip'), + dict( + type='Normalize', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img']) + ]) +] +data = dict( + samples_per_gpu=2, + workers_per_gpu=2, + train=dict( + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + classes=('ignored', 'vehicle',), + ann_file='data/annotations/instances_train2017car.json', + img_prefix='data/train2017', + min_size=20, + pipeline=train_pipeline)), + val=dict( + type=dataset_type, + classes=('ignored', 'vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline), + test=dict( + type=dataset_type, + classes=('ignored', 'vehicle',), + ann_file='data/annotations/instances_val2017car.json', + img_prefix='data/val2017', + test_mode=True, + pipeline=test_pipeline)) +evaluation = dict(interval=1, metric='bbox') +optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2)) +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=500, + warmup_ratio=0.3333333333333333, + step=[8, 11]) +checkpoint_config = dict(interval=1) +log_config = dict( + interval=50, + hooks=[dict(type='TextLoggerHook'), + dict(type='TensorboardLoggerHook')]) +total_epochs = 12 +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = './cascade_r50' +load_from = None +resume_from = None +workflow = [('train', 1)] +gpu_ids = range(0, 1) diff --git a/external/mmdetection/constraints.txt b/external/mmdetection/constraints.txt new file mode 100644 index 00000000000..e8cb64eca06 --- /dev/null +++ b/external/mmdetection/constraints.txt @@ -0,0 +1,119 @@ +absl-py==0.15.0 +addict==2.4.0 +albumentations==0.4.6 +antlr4-python3-runtime==4.8 +asynctest==0.13.0 +attrs==21.2.0 +cachetools==4.2.4 +certifi==2021.10.8 +chardet==4.0.0 +click==8.0.3 +codecov==2.1.12 +colorama==0.4.4 +coverage==6.0.2 +cycler==0.10.0 +Cython==0.29.24 +decorator==4.4.2 +defusedxml==0.7.1 +editdistance==0.6.0 +fast_ctc_decode==0.3.0 +flake8==4.0.1 +flatbuffers==1.12 +future==0.18.2 +google-auth==1.35.0 +google-auth-oauthlib==0.4.6 +grpcio==1.32.0 +hyperopt==0.1.2 +idna==2.10 +imagecorruptions==1.1.2 +imageio==2.9.0 +imagesize==1.2.0 +imgaug==0.4.0 +iniconfig==1.1.1 +interrogate==1.5.0 +isort==4.3.21 +joblib==1.1.0 +jsonschema==3.2.0 +jstyleson==0.0.2 +kiwisolver==1.3.2 +kwarray==0.5.19 +Markdown==3.3.4 +matplotlib==3.4.3 +mccabe==0.6.1 +mmcv-full==1.3.14 +mmpycocotools==12.0.3 +natsort==7.1.1 +networkx==2.6.3 +nibabel==3.2.1 +ninja==1.10.2.2 +nltk==3.6.5 +numpy==1.19.5 +oauthlib==3.1.1 +omegaconf==2.1.1 +onnx==1.10.1 +onnxoptimizer==0.2.6 +onnxruntime==1.9.0 +opencv-python==4.5.3.56 +openvino==2022.1.0.dev20220302 +openvino-dev==2022.1.0.dev20220302 +ordered-set==4.0.2 +packaging==21.0 +pandas==1.1.5 +parasail==1.2.4 +Pillow==8.4.0 +pkg_resources==0.0.0 +pluggy==1.0.0 +progress==1.6 +protobuf==3.14.0 +py==1.10.0 +py-cpuinfo==8.0.0 +pyasn1==0.4.8 +pyasn1-modules==0.2.8 +pycodestyle==2.8.0 +pydicom==2.2.2 +pydot==1.4.2 +pyflakes==2.4.0 +pymongo==3.12.0 +pyparsing==2.4.7 +pyrsistent==0.18.0 +pytest==6.2.5 +python-dateutil==2.8.1 +pytorchcv==0.0.55 +pytz==2021.3 +PyWavelets==1.1.1 +PyYAML==5.4.1 +rawpy==0.16.0 +regex==2021.10.21 +requests==2.26.0 +requests-oauthlib==1.3.0 +rsa==4.7.2 +scikit-image==0.17.2 +scikit-learn==0.24.2 +scipy==1.5.4 +sentencepiece==0.1.96 +Shapely==1.8.0 +six==1.15.0 +sklearn==0.0 +sty==1.0.0b12 +tabulate==0.8.9 +tensorboard==2.7.0 +tensorboard-data-server==0.6.1 +tensorboard-plugin-wit==1.8.0 +terminaltables==3.1.0 +testfixtures==6.18.3 +texttable==1.6.4 +threadpoolctl==3.0.0 +tifffile==2021.10.12 +tokenizers==0.10.3 +toml==0.10.2 +tqdm==4.62.3 +typing-extensions==3.7.4.3 +ubelt==0.10.1 +urllib3==1.26.7 +Werkzeug==2.0.2 +xdoctest==0.15.10 +yamlloader==1.1.0 +yapf==0.31.0 + +importlib-metadata==4.2.0 +ipython==7.31.1 diff --git a/external/mmdetection/detection_tasks/__init__.py b/external/mmdetection/detection_tasks/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/external/mmdetection/detection_tasks/apis/__init__.py b/external/mmdetection/detection_tasks/apis/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/external/mmdetection/detection_tasks/apis/detection/__init__.py b/external/mmdetection/detection_tasks/apis/detection/__init__.py new file mode 100644 index 00000000000..03c0dce1f69 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/__init__.py @@ -0,0 +1,42 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + + +from .config_utils import (config_from_string, config_to_string, patch_config, + prepare_for_testing, prepare_for_training, + save_config_to_file, set_hyperparams) +from .configuration import OTEDetectionConfig +from .inference_task import OTEDetectionInferenceTask +from .nncf_task import OTEDetectionNNCFTask +from .openvino_task import OpenVINODetectionTask +from .ote_utils import generate_label_schema, get_task_class, load_template +from .train_task import OTEDetectionTrainingTask + +__all__ = [ + config_from_string, + config_to_string, + generate_label_schema, + get_task_class, + load_template, + OpenVINODetectionTask, + OTEDetectionConfig, + OTEDetectionInferenceTask, + OTEDetectionNNCFTask, + OTEDetectionTrainingTask, + patch_config, + prepare_for_testing, + prepare_for_training, + save_config_to_file, + set_hyperparams, + ] diff --git a/external/mmdetection/detection_tasks/apis/detection/config_utils.py b/external/mmdetection/detection_tasks/apis/detection/config_utils.py new file mode 100644 index 00000000000..3a8c59147b1 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/config_utils.py @@ -0,0 +1,333 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import copy +import glob +import math +import os +import tempfile +from collections import defaultdict +from typing import List, Optional + +from mmcv import Config, ConfigDict +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.label import LabelEntity, Domain +from ote_sdk.usecases.reporting.time_monitor_callback import TimeMonitorCallback + +from detection_tasks.extension.datasets.data_utils import get_anchor_boxes, \ + get_sizes_from_dataset_entity, format_list_to_str +from mmdet.models.detectors import BaseDetector +from mmdet.utils.logger import get_root_logger + +from .configuration import OTEDetectionConfig + +try: + from sklearn.cluster import KMeans + kmeans_import = True +except ImportError: + kmeans_import = False + + +logger = get_root_logger() + + +def is_epoch_based_runner(runner_config: ConfigDict): + return 'Epoch' in runner_config.type + + +def patch_config(config: Config, work_dir: str, labels: List[LabelEntity], domain: Domain, random_seed: Optional[int] = None): + # Set runner if not defined. + if 'runner' not in config: + config.runner = {'type': 'EpochBasedRunner'} + + # Check that there is no conflict in specification of number of training epochs. + # Move global definition of epochs inside runner config. + if 'total_epochs' in config: + if is_epoch_based_runner(config.runner): + if config.runner.max_epochs != config.total_epochs: + logger.warning('Conflicting declaration of training epochs number.') + config.runner.max_epochs = config.total_epochs + else: + logger.warning(f'Total number of epochs set for an iteration based runner {config.runner.type}.') + remove_from_config(config, 'total_epochs') + + # Change runner's type. + if is_epoch_based_runner(config.runner): + logger.info(f'Replacing runner from {config.runner.type} to EpochRunnerWithCancel.') + config.runner.type = 'EpochRunnerWithCancel' + else: + logger.info(f'Replacing runner from {config.runner.type} to IterBasedRunnerWithCancel.') + config.runner.type = 'IterBasedRunnerWithCancel' + + # Add training cancelation hook. + if 'custom_hooks' not in config: + config.custom_hooks = [] + if 'CancelTrainingHook' not in {hook.type for hook in config.custom_hooks}: + config.custom_hooks.append({'type': 'CancelTrainingHook'}) + + # Remove high level data pipelines definition leaving them only inside `data` section. + remove_from_config(config, 'train_pipeline') + remove_from_config(config, 'test_pipeline') + + # Patch data pipeline, making it OTE-compatible. + patch_datasets(config, domain) + + if 'log_config' not in config: + config.log_config = ConfigDict() + # config.log_config.hooks = [] + + if 'evaluation' not in config: + config.evaluation = ConfigDict() + evaluation_metric = config.evaluation.get('metric') + if evaluation_metric is not None: + config.evaluation.save_best = evaluation_metric + + if 'checkpoint_config' not in config: + config.checkpoint_config = ConfigDict() + config.checkpoint_config.max_keep_ckpts = 5 + config.checkpoint_config.interval = config.evaluation.get('interval', 1) + + set_data_classes(config, labels) + + config.gpu_ids = range(1) + config.work_dir = work_dir + config.seed = random_seed + + +def set_hyperparams(config: Config, hyperparams: OTEDetectionConfig): + config.optimizer.lr = float(hyperparams.learning_parameters.learning_rate) + config.lr_config.warmup_iters = int(hyperparams.learning_parameters.learning_rate_warmup_iters) + if config.lr_config.warmup_iters == 0: + config.lr_config.warmup = None + config.data.samples_per_gpu = int(hyperparams.learning_parameters.batch_size) + config.data.workers_per_gpu = int(hyperparams.learning_parameters.num_workers) + total_iterations = int(hyperparams.learning_parameters.num_iters) + if is_epoch_based_runner(config.runner): + config.runner.max_epochs = total_iterations + else: + config.runner.max_iters = total_iterations + + +def patch_adaptive_repeat_dataset(config: Config, num_samples: int, + decay: float = -0.002, factor: float = 30): + """ Patch the repeat times and training epochs adatively + + Frequent dataloading inits and evaluation slow down training when the + sample size is small. Adjusting epoch and dataset repetition based on + empirical exponential decay improves the training time by applying high + repeat value to small sample size dataset and low repeat value to large + sample. + + :param config: mmcv config + :param num_samples: number of training samples + :param decay: decaying rate + :param factor: base repeat factor + """ + if config.data.train.type == 'RepeatDataset' and getattr( + config.data.train, 'adaptive_repeat_times', False): + if is_epoch_based_runner(config.runner): + cur_epoch = config.runner.max_epochs + new_repeat = max(round(math.exp(decay * num_samples) * factor), 1) + new_epoch = math.ceil(cur_epoch / new_repeat) + if new_epoch == 1: + return + config.runner.max_epochs = new_epoch + config.data.train.times = new_repeat + + +def prepare_for_testing(config: Config, dataset: DatasetEntity) -> Config: + config = copy.deepcopy(config) + # FIXME. Should working directories be modified here? + config.data.test.ote_dataset = dataset + return config + + +def prepare_for_training(config: Config, train_dataset: DatasetEntity, val_dataset: DatasetEntity, + time_monitor: TimeMonitorCallback, learning_curves: defaultdict) -> Config: + config = copy.deepcopy(config) + prepare_work_dir(config) + config.data.val.ote_dataset = val_dataset + if 'ote_dataset' in config.data.train: + config.data.train.ote_dataset = train_dataset + else: + config.data.train.dataset.ote_dataset = train_dataset + patch_adaptive_repeat_dataset(config, len(train_dataset)) + config.custom_hooks.append({'type': 'OTEProgressHook', 'time_monitor': time_monitor, 'verbose': True}) + config.log_config.hooks.append({'type': 'OTELoggerHook', 'curves': learning_curves}) + return config + + +def config_to_string(config: Config) -> str: + """ + Convert a full mmdetection config to a string. + + :param config: configuration object to convert + :return str: string representation of the configuration + """ + config_copy = copy.deepcopy(config) + # Clean config up by removing dataset as this causes the pretty text parsing to fail. + config_copy.data.test.ote_dataset = None + config_copy.data.test.labels = None + config_copy.data.val.ote_dataset = None + config_copy.data.val.labels = None + if 'ote_dataset' in config_copy.data.train: + config_copy.data.train.ote_dataset = None + config_copy.data.train.labels = None + else: + config_copy.data.train.dataset.ote_dataset = None + config_copy.data.train.dataset.labels = None + return Config(config_copy).pretty_text + + +def config_from_string(config_string: str) -> Config: + """ + Generate an mmdetection config dict object from a string. + + :param config_string: string to parse + :return config: configuration object + """ + with tempfile.NamedTemporaryFile('w', suffix='.py') as temp_file: + temp_file.write(config_string) + temp_file.flush() + return Config.fromfile(temp_file.name) + + +def save_config_to_file(config: Config): + """ Dump the full config to a file. Filename is 'config.py', it is saved in the current work_dir. """ + filepath = os.path.join(config.work_dir, 'config.py') + config_string = config_to_string(config) + with open(filepath, 'w') as f: + f.write(config_string) + + +def prepare_work_dir(config: Config) -> str: + base_work_dir = config.work_dir + checkpoint_dirs = glob.glob(os.path.join(base_work_dir, "checkpoints_round_*")) + train_round_checkpoint_dir = os.path.join(base_work_dir, f"checkpoints_round_{len(checkpoint_dirs)}") + os.makedirs(train_round_checkpoint_dir) + logger.info(f"Checkpoints and logs for this training run are stored in {train_round_checkpoint_dir}") + config.work_dir = train_round_checkpoint_dir + if 'meta' not in config.runner: + config.runner.meta = ConfigDict() + config.runner.meta.exp_name = f"train_round_{len(checkpoint_dirs)}" + # Save training config for debugging. It is saved in the checkpoint dir for this training round. + # save_config_to_file(config) + return train_round_checkpoint_dir + + +def set_data_classes(config: Config, labels: List[LabelEntity]): + # Save labels in data configs. + for subset in ('train', 'val', 'test'): + cfg = config.data[subset] + if cfg.type == 'RepeatDataset' or cfg.type == 'MultiImageMixDataset': + cfg.dataset.labels = labels + else: + cfg.labels = labels + config.data[subset].labels = labels + + # Set proper number of classes in model's detection heads. + head_names = ('mask_head', 'bbox_head', 'segm_head') + num_classes = len(labels) + if 'roi_head' in config.model: + for head_name in head_names: + if head_name in config.model.roi_head: + if isinstance(config.model.roi_head[head_name], List): + for head in config.model.roi_head[head_name]: + head.num_classes = num_classes + else: + config.model.roi_head[head_name].num_classes = num_classes + else: + for head_name in head_names: + if head_name in config.model: + config.model[head_name].num_classes = num_classes + # FIXME. ? + # self.config.model.CLASSES = label_names + + +def patch_datasets(config: Config, domain): + + def patch_color_conversion(pipeline): + # Default data format for OTE is RGB, while mmdet uses BGR, so negate the color conversion flag. + for pipeline_step in pipeline: + if pipeline_step.type == 'Normalize': + to_rgb = False + if 'to_rgb' in pipeline_step: + to_rgb = pipeline_step.to_rgb + to_rgb = not bool(to_rgb) + pipeline_step.to_rgb = to_rgb + elif pipeline_step.type == 'MultiScaleFlipAug': + patch_color_conversion(pipeline_step.transforms) + + assert 'data' in config + for subset in ('train', 'val', 'test'): + cfg = config.data[subset] + if cfg.type == 'RepeatDataset' or cfg.type == 'MultiImageMixDataset': + cfg = cfg.dataset + cfg.type = 'OTEDataset' + cfg.domain = domain + cfg.ote_dataset = None + cfg.labels = None + remove_from_config(cfg, 'ann_file') + remove_from_config(cfg, 'img_prefix') + for pipeline_step in cfg.pipeline: + if pipeline_step.type == 'LoadImageFromFile': + pipeline_step.type = 'LoadImageFromOTEDataset' + if pipeline_step.type == 'LoadAnnotations': + pipeline_step.type = 'LoadAnnotationFromOTEDataset' + pipeline_step.domain = domain + pipeline_step.min_size = cfg.pop('min_size', -1) + patch_color_conversion(cfg.pipeline) + + +def remove_from_config(config, key: str): + if key in config: + if isinstance(config, Config): + del config._cfg_dict[key] + elif isinstance(config, ConfigDict): + del config[key] + else: + raise ValueError(f'Unknown config type {type(config)}') + +def cluster_anchors(config: Config, dataset: DatasetEntity, model: BaseDetector): + if not kmeans_import: + raise ImportError('Sklearn package is not installed. To enable anchor boxes clustering, please install ' + 'packages from requirements/optional.txt or just scikit-learn package.') + + logger.info('Collecting statistics from training dataset to cluster anchor boxes...') + [target_wh] = [transforms.img_scale for transforms in config.data.test.pipeline + if transforms.type == 'MultiScaleFlipAug'] + prev_generator = config.model.bbox_head.anchor_generator + group_as = [len(width) for width in prev_generator.widths] + wh_stats = get_sizes_from_dataset_entity(dataset, target_wh) + + if len(wh_stats) < sum(group_as): + logger.warning(f'There are not enough objects to cluster: {len(wh_stats)} were detected, while it should be ' + f'at least {sum(group_as)}. Anchor box clustering was skipped.') + return config, model + + widths, heights = get_anchor_boxes(wh_stats, group_as) + logger.info(f'Anchor boxes widths have been updated from {format_list_to_str(prev_generator.widths)} ' + f'to {format_list_to_str(widths)}') + logger.info(f'Anchor boxes heights have been updated from {format_list_to_str(prev_generator.heights)} ' + f'to {format_list_to_str(heights)}') + config_generator = config.model.bbox_head.anchor_generator + config_generator.widths, config_generator.heights = widths, heights + + model_generator = model.bbox_head.anchor_generator + model_generator.widths, model_generator.heights = widths, heights + model_generator.base_anchors = model_generator.gen_base_anchors() + + config.model.bbox_head.anchor_generator = config_generator + model.bbox_head.anchor_generator = model_generator + return config, model diff --git a/external/mmdetection/detection_tasks/apis/detection/configuration.py b/external/mmdetection/detection_tasks/apis/detection/configuration.py new file mode 100644 index 00000000000..661c4b428b5 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/configuration.py @@ -0,0 +1,161 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from attr import attrs +from sys import maxsize + +from ote_sdk.configuration.elements import (ParameterGroup, + add_parameter_group, + configurable_boolean, + configurable_float, + configurable_integer, + selectable, + string_attribute) +from ote_sdk.configuration import ConfigurableParameters +from ote_sdk.configuration.model_lifecycle import ModelLifecycle + +from .configuration_enums import POTQuantizationPreset + + +@attrs +class OTEDetectionConfig(ConfigurableParameters): + header = string_attribute("Configuration for an object detection task") + description = header + + @attrs + class __LearningParameters(ParameterGroup): + header = string_attribute("Learning Parameters") + description = header + + batch_size = configurable_integer( + default_value=5, + min_value=1, + max_value=512, + header="Batch size", + description="The number of training samples seen in each iteration of training. Increasing this value " + "improves training time and may make the training more stable. A larger batch size has higher " + "memory requirements.", + warning="Increasing this value may cause the system to use more memory than available, " + "potentially causing out of memory errors, please update with caution.", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + num_iters = configurable_integer( + default_value=1, + min_value=1, + max_value=100000, + header="Number of training iterations", + description="Increasing this value causes the results to be more robust but training time will be longer.", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + learning_rate = configurable_float( + default_value=0.01, + min_value=1e-07, + max_value=1e-01, + header="Learning rate", + description="Increasing this value will speed up training convergence but might make it unstable.", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + learning_rate_warmup_iters = configurable_integer( + default_value=100, + min_value=0, + max_value=10000, + header="Number of iterations for learning rate warmup", + description="", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + num_workers = configurable_integer( + default_value=4, + min_value=0, + max_value=36, + header="Number of cpu threads to use during batch generation", + description="Increasing this value might improve training speed however it might cause out of memory " + "errors. If the number of workers is set to zero, data loading will happen in the main " + "training thread.", + affects_outcome_of=ModelLifecycle.NONE + ) + + @attrs + class __Postprocessing(ParameterGroup): + header = string_attribute("Postprocessing") + description = header + + result_based_confidence_threshold = configurable_boolean( + default_value=True, + header="Result based confidence threshold", + description="Confidence threshold is derived from the results", + affects_outcome_of=ModelLifecycle.INFERENCE + ) + + confidence_threshold = configurable_float( + default_value=0.35, + min_value=0, + max_value=1, + header="Confidence threshold", + description="This threshold only takes effect if the threshold is not set based on the result.", + affects_outcome_of=ModelLifecycle.INFERENCE + ) + + @attrs + class __NNCFOptimization(ParameterGroup): + header = string_attribute("Optimization by NNCF") + description = header + + enable_quantization = configurable_boolean( + default_value=True, + header="Enable quantization algorithm", + description="Enable quantization algorithm", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + enable_pruning = configurable_boolean( + default_value=False, + header="Enable filter pruning algorithm", + description="Enable filter pruning algorithm", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + maximal_accuracy_degradation = configurable_float( + default_value=1.0, + min_value=0.0, + max_value=100.0, + header="Maximum accuracy degradation", + description="The maximal allowed accuracy metric drop", + affects_outcome_of=ModelLifecycle.TRAINING + ) + + @attrs + class __POTParameter(ParameterGroup): + header = string_attribute("POT Parameters") + description = header + + stat_subset_size = configurable_integer( + header="Number of data samples", + description="Number of data samples used for post-training optimization", + default_value=300, + min_value=1, + max_value=maxsize + ) + + preset = selectable(default_value=POTQuantizationPreset.PERFORMANCE, header="Preset", + description="Quantization preset that defines quantization scheme", + editable=True, visible_in_ui=True) + + learning_parameters = add_parameter_group(__LearningParameters) + postprocessing = add_parameter_group(__Postprocessing) + nncf_optimization = add_parameter_group(__NNCFOptimization) + pot_parameters = add_parameter_group(__POTParameter) diff --git a/external/mmdetection/detection_tasks/apis/detection/configuration.yaml b/external/mmdetection/detection_tasks/apis/detection/configuration.yaml new file mode 100644 index 00000000000..02d92ca9a15 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/configuration.yaml @@ -0,0 +1,238 @@ +description: Configuration for an object detection task +header: Configuration for an object detection task +learning_parameters: + batch_size: + affects_outcome_of: TRAINING + default_value: 5 + description: + The number of training samples seen in each iteration of training. + Increasing this value improves training time and may make the training more + stable. A larger batch size has higher memory requirements. + editable: true + header: Batch size + max_value: 512 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 5 + visible_in_ui: true + warning: + Increasing this value may cause the system to use more memory than available, + potentially causing out of memory errors, please update with caution. + description: Learning Parameters + header: Learning Parameters + learning_rate: + affects_outcome_of: TRAINING + default_value: 0.01 + description: + Increasing this value will speed up training convergence but might + make it unstable. + editable: true + header: Learning rate + max_value: 0.1 + min_value: 1.0e-07 + type: FLOAT + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 0.01 + visible_in_ui: true + warning: null + learning_rate_warmup_iters: + affects_outcome_of: TRAINING + default_value: 100 + description: "" + editable: true + header: Number of iterations for learning rate warmup + max_value: 10000 + min_value: 0 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 100 + visible_in_ui: true + warning: null + num_iters: + affects_outcome_of: TRAINING + default_value: 1 + description: + Increasing this value causes the results to be more robust but training + time will be longer. + editable: true + header: Number of training iterations + max_value: 100000 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 1 + visible_in_ui: true + warning: null + num_workers: + affects_outcome_of: NONE + default_value: 4 + description: + Increasing this value might improve training speed however it might + cause out of memory errors. If the number of workers is set to zero, data loading + will happen in the main training thread. + editable: true + header: Number of cpu threads to use during batch generation + max_value: 36 + min_value: 0 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 4 + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true +postprocessing: + confidence_threshold: + affects_outcome_of: INFERENCE + default_value: 0.35 + description: + This threshold only takes effect if the threshold is not set based + on the result. + editable: true + header: Confidence threshold + max_value: 1 + min_value: 0 + type: FLOAT + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 0.35 + visible_in_ui: true + warning: null + description: Postprocessing + header: Postprocessing + result_based_confidence_threshold: + affects_outcome_of: INFERENCE + default_value: true + description: Confidence threshold is derived from the results + editable: true + header: Result based confidence threshold + type: BOOLEAN + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: true + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true +type: CONFIGURABLE_PARAMETERS +visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true +nncf_optimization: + description: Optimization by NNCF + header: Optimization by NNCF + enable_quantization: + affects_outcome_of: TRAINING + default_value: true + description: Enable quantization algorithm + editable: true + header: Enable quantization algorithm + type: BOOLEAN + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: true + visible_in_ui: true + warning: null + enable_pruning: + affects_outcome_of: TRAINING + default_value: false + description: Enable filter pruning algorithm + editable: true + header: Enable filter pruning algorithm + type: BOOLEAN + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: false + visible_in_ui: true + warning: null + maximal_accuracy_degradation: + affects_outcome_of: TRAINING + default_value: 1.0 + description: The maximal allowed accuracy metric drop + editable: true + header: Maximum accuracy degradation + max_value: 100.0 + min_value: 0.0 + type: FLOAT + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 1.0 + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true diff --git a/external/mmdetection/detection_tasks/apis/detection/configuration_enums.py b/external/mmdetection/detection_tasks/apis/detection/configuration_enums.py new file mode 100644 index 00000000000..067e193a374 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/configuration_enums.py @@ -0,0 +1,22 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from ote_sdk.configuration import ConfigurableEnum + +class POTQuantizationPreset(ConfigurableEnum): + """ + This Enum represents the quantization preset for post training optimization + """ + PERFORMANCE = 'Performance' + MIXED = 'Mixed' diff --git a/external/mmdetection/detection_tasks/apis/detection/inference_task.py b/external/mmdetection/detection_tasks/apis/detection/inference_task.py new file mode 100644 index 00000000000..78dfabc0def --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/inference_task.py @@ -0,0 +1,406 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import copy +import io +import os +import shutil +import tempfile +import warnings +from subprocess import run # nosec +from typing import List, Optional, Tuple + +import cv2 +import numpy as np +import torch +from mmcv.parallel import MMDataParallel +from mmcv.runner import load_checkpoint, load_state_dict +from mmcv.utils import Config +from ote_sdk.entities.annotation import Annotation +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.id import ID +from ote_sdk.entities.inference_parameters import InferenceParameters, default_progress_callback +from ote_sdk.entities.model import ModelEntity, ModelFormat, ModelOptimizationType, ModelPrecision, OptimizationMethod +from ote_sdk.entities.model_template import TaskType, task_type_to_label_domain +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.entities.scored_label import ScoredLabel +from ote_sdk.entities.shapes.polygon import Point, Polygon +from ote_sdk.entities.shapes.rectangle import Rectangle +from ote_sdk.entities.task_environment import TaskEnvironment +from ote_sdk.entities.tensor import TensorEntity +from ote_sdk.usecases.evaluation.metrics_helper import MetricsHelper +from ote_sdk.usecases.tasks.interfaces.evaluate_interface import IEvaluationTask +from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType, IExportTask +from ote_sdk.usecases.tasks.interfaces.inference_interface import IInferenceTask +from ote_sdk.usecases.tasks.interfaces.unload_interface import IUnload +from ote_sdk.serialization.label_mapper import label_schema_to_bytes + +from mmdet.apis import export_model +from detection_tasks.apis.detection.config_utils import patch_config, prepare_for_testing, set_hyperparams +from detection_tasks.apis.detection.configuration import OTEDetectionConfig +from detection_tasks.apis.detection.ote_utils import InferenceProgressCallback +from mmdet.datasets import build_dataloader, build_dataset +from mmdet.models import build_detector +from mmdet.parallel import MMDataCPU +from mmdet.utils.collect_env import collect_env +from mmdet.utils.logger import get_root_logger + +logger = get_root_logger() + + +class OTEDetectionInferenceTask(IInferenceTask, IExportTask, IEvaluationTask, IUnload): + + _task_environment: TaskEnvironment + + def __init__(self, task_environment: TaskEnvironment): + """" + Task for inference object detection models using OTEDetection. + """ + logger.info('Loading OTEDetectionTask') + + print('ENVIRONMENT:') + for name, val in collect_env().items(): + print(f'{name}: {val}') + print('pip list:') + run('pip list', shell=True, check=True) + + self._task_environment = task_environment + self._task_type = task_environment.model_template.task_type + self._scratch_space = tempfile.mkdtemp(prefix="ote-det-scratch-") + logger.info(f'Scratch space created at {self._scratch_space}') + + self._model_name = task_environment.model_template.name + self._labels = task_environment.get_labels(False) + + template_file_path = task_environment.model_template.model_template_path + + # Get and prepare mmdet config. + self._base_dir = os.path.abspath(os.path.dirname(template_file_path)) + config_file_path = os.path.join(self._base_dir, "model.py") + self._config = Config.fromfile(config_file_path) + patch_config(self._config, self._scratch_space, self._labels, task_type_to_label_domain(self._task_type), random_seed=42) + set_hyperparams(self._config, self._hyperparams) + self.confidence_threshold: float = self._hyperparams.postprocessing.confidence_threshold + + # Set default model attributes. + self._optimization_methods = [] + self._precision = [ModelPrecision.FP32] + self._optimization_type = ModelOptimizationType.MO + + # Create and initialize PyTorch model. + logger.info('Loading the model') + self._model = self._load_model(task_environment.model) + + # Extra control variables. + self._training_work_dir = None + self._is_training = False + self._should_stop = False + logger.info('Task initialization completed') + + @property + def _hyperparams(self): + return self._task_environment.get_hyper_parameters(OTEDetectionConfig) + + def _load_model(self, model: ModelEntity): + if model is not None: + # If a model has been trained and saved for the task already, create empty model and load weights here + buffer = io.BytesIO(model.get_data("weights.pth")) + model_data = torch.load(buffer, map_location=torch.device('cpu')) + + self.confidence_threshold = model_data.get('confidence_threshold', self.confidence_threshold) + if model_data.get('anchors'): + anchors = model_data['anchors'] + self._config.model.bbox_head.anchor_generator.heights = anchors['heights'] + self._config.model.bbox_head.anchor_generator.widths = anchors['widths'] + + model = self._create_model(self._config, from_scratch=True) + + try: + load_state_dict(model, model_data['model']) + logger.info(f"Loaded model weights from Task Environment") + logger.info(f"Model architecture: {self._model_name}") + except BaseException as ex: + raise ValueError("Could not load the saved model. The model file structure is invalid.") \ + from ex + else: + # If there is no trained model yet, create model with pretrained weights as defined in the model config + # file. + model = self._create_model(self._config, from_scratch=False) + logger.info(f"No trained model in project yet. Created new model with '{self._model_name}' " + f"architecture and general-purpose pretrained weights.") + return model + + + @staticmethod + def _create_model(config: Config, from_scratch: bool = False): + """ + Creates a model, based on the configuration in config + + :param config: mmdetection configuration from which the model has to be built + :param from_scratch: bool, if True does not load any weights + + :return model: ModelEntity in training mode + """ + model_cfg = copy.deepcopy(config.model) + + init_from = None if from_scratch else config.get('load_from', None) + logger.warning(init_from) + if init_from is not None: + # No need to initialize backbone separately, if all weights are provided. + model_cfg.pretrained = None + logger.warning('build detector') + model = build_detector(model_cfg) + # Load all weights. + logger.warning('load checkpoint') + load_checkpoint(model, init_from, map_location='cpu') + else: + logger.warning('build detector') + model = build_detector(model_cfg) + return model + + + def _add_predictions_to_dataset(self, prediction_results, dataset, confidence_threshold=0.0): + """ Loop over dataset again to assign predictions. Convert from MMDetection format to OTE format. """ + for dataset_item, (all_results, feature_vector) in zip(dataset, prediction_results): + width = dataset_item.width + height = dataset_item.height + + shapes = [] + if self._task_type == TaskType.DETECTION: + for label_idx, detections in enumerate(all_results): + for i in range(detections.shape[0]): + probability = float(detections[i, 4]) + coords = detections[i, :4].astype(float).copy() + coords /= np.array([width, height, width, height], dtype=float) + coords = np.clip(coords, 0, 1) + + if probability < confidence_threshold: + continue + + assigned_label = [ScoredLabel(self._labels[label_idx], + probability=probability)] + if coords[3] - coords[1] <= 0 or coords[2] - coords[0] <= 0: + continue + + shapes.append(Annotation( + Rectangle(x1=coords[0], y1=coords[1], x2=coords[2], y2=coords[3]), + labels=assigned_label)) + elif self._task_type in {TaskType.INSTANCE_SEGMENTATION, TaskType.ROTATED_DETECTION}: + for label_idx, (boxes, masks) in enumerate(zip(*all_results)): + for mask, probability in zip(masks, boxes[:, 4]): + mask = mask.astype(np.uint8) + probability = float(probability) + contours, hierarchies = cv2.findContours(mask, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) + if hierarchies is None: + continue + for contour, hierarchy in zip(contours, hierarchies[0]): + if hierarchy[3] != -1: + continue + if len(contour) <= 2 or probability < confidence_threshold: + continue + if self._task_type == TaskType.INSTANCE_SEGMENTATION: + points = [Point(x=point[0][0] / width, y=point[0][1] / height) for point in contour] + else: + box_points = cv2.boxPoints(cv2.minAreaRect(contour)) + points = [Point(x=point[0] / width, y=point[1] / height) for point in box_points] + labels = [ScoredLabel(self._labels[label_idx], probability=probability)] + shapes.append(Annotation(Polygon(points=points), labels=labels, id=ID(f"{label_idx:08}"))) + else: + raise RuntimeError( + f"Detection results assignment not implemented for task: {self._task_type}") + + dataset_item.append_annotations(shapes) + + if feature_vector is not None: + active_score = TensorEntity(name="representation_vector", numpy=feature_vector) + dataset_item.append_metadata_item(active_score, model=self._task_environment.model) + + + def infer(self, dataset: DatasetEntity, inference_parameters: Optional[InferenceParameters] = None) -> DatasetEntity: + """ Analyzes a dataset using the latest inference model. """ + + logger.info('Infer the model on the dataset') + set_hyperparams(self._config, self._hyperparams) + # There is no need to have many workers for a couple of images. + self._config.data.workers_per_gpu = max(min(self._config.data.workers_per_gpu, len(dataset) - 1), 0) + + # If confidence threshold is adaptive then up-to-date value should be stored in the model + # and should not be changed during inference. Otherwise user-specified value should be taken. + if not self._hyperparams.postprocessing.result_based_confidence_threshold: + self.confidence_threshold = self._hyperparams.postprocessing.confidence_threshold + + update_progress_callback = default_progress_callback + if inference_parameters is not None: + update_progress_callback = inference_parameters.update_progress + + time_monitor = InferenceProgressCallback(len(dataset), update_progress_callback) + + def pre_hook(module, input): + time_monitor.on_test_batch_begin(None, None) + + def hook(module, input, output): + time_monitor.on_test_batch_end(None, None) + + logger.info(f'Confidence threshold {self.confidence_threshold}') + model = self._model + with model.register_forward_pre_hook(pre_hook), model.register_forward_hook(hook): + prediction_results, _ = self._infer_detector(model, self._config, dataset, dump_features=True, eval=False) + self._add_predictions_to_dataset(prediction_results, dataset, self.confidence_threshold) + + logger.info('Inference completed') + return dataset + + + @staticmethod + def _infer_detector(model: torch.nn.Module, config: Config, dataset: DatasetEntity, dump_features: bool = False, + eval: Optional[bool] = False, metric_name: Optional[str] = 'mAP') -> Tuple[List, float]: + model.eval() + test_config = prepare_for_testing(config, dataset) + mm_val_dataset = build_dataset(test_config.data.test) + batch_size = 1 + mm_val_dataloader = build_dataloader(mm_val_dataset, + samples_per_gpu=batch_size, + workers_per_gpu=test_config.data.workers_per_gpu, + num_gpus=1, + dist=False, + shuffle=False) + if torch.cuda.is_available(): + eval_model = MMDataParallel(model.cuda(test_config.gpu_ids[0]), + device_ids=test_config.gpu_ids) + else: + eval_model = MMDataCPU(model) + + eval_predictions = [] + feature_vectors = [] + + def dump_features_hook(mod, inp, out): + with torch.no_grad(): + feature_map = out[-1] + feature_vector = torch.nn.functional.adaptive_avg_pool2d(feature_map, (1, 1)) + assert feature_vector.size(0) == 1 + feature_vectors.append(feature_vector.view(-1).detach().cpu().numpy()) + + def dummy_dump_features_hook(mod, inp, out): + feature_vectors.append(None) + + hook = dump_features_hook if dump_features else dummy_dump_features_hook + + # Use a single gpu for testing. Set in both mm_val_dataloader and eval_model + with eval_model.module.backbone.register_forward_hook(hook): + for data in mm_val_dataloader: + with torch.no_grad(): + result = eval_model(return_loss=False, rescale=True, **data) + eval_predictions.extend(result) + + # hard-code way to remove EvalHook args + for key in [ + 'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best', + 'rule', 'dynamic_intervals' + ]: + config.evaluation.pop(key, None) + + metric = None + if eval: + metric = mm_val_dataset.evaluate(eval_predictions, **config.evaluation)[metric_name] + + assert len(eval_predictions) == len(feature_vectors), f'{len(eval_predictions)} != {len(feature_vectors)}' + eval_predictions = zip(eval_predictions, feature_vectors) + return eval_predictions, metric + + + def evaluate(self, + output_result_set: ResultSetEntity, + evaluation_metric: Optional[str] = None): + """ Computes performance on a resultset """ + logger.info('Evaluating the metric') + if evaluation_metric is not None: + logger.warning(f'Requested to use {evaluation_metric} metric, but parameter is ignored. Use F-measure instead.') + metric = MetricsHelper.compute_f_measure(output_result_set) + logger.info(f"F-measure after evaluation: {metric.f_measure.value}") + output_result_set.performance = metric.get_performance() + logger.info('Evaluation completed') + + + @staticmethod + def _is_docker(): + """ + Checks whether the task runs in docker container + + :return bool: True if task runs in docker + """ + path = '/proc/self/cgroup' + is_in_docker = False + if os.path.isfile(path): + with open(path) as f: + is_in_docker = is_in_docker or any('docker' in line for line in f) + is_in_docker = is_in_docker or os.path.exists('/.dockerenv') + return is_in_docker + + def unload(self): + """ + Unload the task + """ + self._delete_scratch_space() + if self._is_docker(): + logger.warning( + "Got unload request. Unloading models. Throwing Segmentation Fault on purpose") + import ctypes + ctypes.string_at(0) + else: + logger.warning("Got unload request, but not on Docker. Only clearing CUDA cache") + torch.cuda.empty_cache() + logger.warning(f"Done unloading. " + f"Torch is still occupying {torch.cuda.memory_allocated()} bytes of GPU memory") + + def export(self, + export_type: ExportType, + output_model: ModelEntity): + logger.info('Exporting the model') + assert export_type == ExportType.OPENVINO + output_model.model_format = ModelFormat.OPENVINO + output_model.optimization_type = self._optimization_type + with tempfile.TemporaryDirectory() as tempdir: + optimized_model_dir = os.path.join(tempdir, 'export') + logger.info(f'Optimized model will be temporarily saved to "{optimized_model_dir}"') + os.makedirs(optimized_model_dir, exist_ok=True) + try: + from torch.jit._trace import TracerWarning + warnings.filterwarnings('ignore', category=TracerWarning) + if torch.cuda.is_available(): + model = self._model.cuda(self._config.gpu_ids[0]) + else: + model = self._model.cpu() + pruning_transformation = OptimizationMethod.FILTER_PRUNING in self._optimization_methods + export_model(model, self._config, tempdir, target='openvino', + pruning_transformation=pruning_transformation) + bin_file = [f for f in os.listdir(tempdir) if f.endswith('.bin')][0] + xml_file = [f for f in os.listdir(tempdir) if f.endswith('.xml')][0] + with open(os.path.join(tempdir, bin_file), "rb") as f: + output_model.set_data('openvino.bin', f.read()) + with open(os.path.join(tempdir, xml_file), "rb") as f: + output_model.set_data('openvino.xml', f.read()) + output_model.set_data('confidence_threshold', np.array([self.confidence_threshold], dtype=np.float32).tobytes()) + output_model.precision = self._precision + output_model.optimization_methods = self._optimization_methods + except Exception as ex: + raise RuntimeError('Optimization was unsuccessful.') from ex + output_model.set_data("label_schema.json", label_schema_to_bytes(self._task_environment.label_schema)) + logger.info('Exporting completed') + + def _delete_scratch_space(self): + """ + Remove model checkpoints and mmdet logs + """ + if os.path.exists(self._scratch_space): + shutil.rmtree(self._scratch_space, ignore_errors=False) diff --git a/external/mmdetection/detection_tasks/apis/detection/model_wrappers/__init__.py b/external/mmdetection/detection_tasks/apis/detection/model_wrappers/__init__.py new file mode 100644 index 00000000000..570552ae1af --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/model_wrappers/__init__.py @@ -0,0 +1,15 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +__all__ = [] diff --git a/external/mmdetection/detection_tasks/apis/detection/nncf_task.py b/external/mmdetection/detection_tasks/apis/detection/nncf_task.py new file mode 100644 index 00000000000..216bd3d0148 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/nncf_task.py @@ -0,0 +1,278 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import io +import json +import os +from collections import defaultdict +from typing import Optional + +import torch +from ote_sdk.configuration import cfg_helper +from ote_sdk.configuration.helper.utils import ids_to_strings +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.model import ( + ModelEntity, + ModelFormat, + ModelOptimizationType, + ModelPrecision, + OptimizationMethod, +) +from ote_sdk.entities.optimization_parameters import default_progress_callback, OptimizationParameters +from ote_sdk.entities.subset import Subset +from ote_sdk.entities.task_environment import TaskEnvironment +from ote_sdk.serialization.label_mapper import label_schema_to_bytes +from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType +from ote_sdk.usecases.tasks.interfaces.optimization_interface import IOptimizationTask +from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType + +from mmdet.apis import train_detector +from mmdet.apis.fake_input import get_fake_input +from detection_tasks.apis.detection.config_utils import prepare_for_training +from detection_tasks.apis.detection.configuration import OTEDetectionConfig +from detection_tasks.apis.detection.inference_task import OTEDetectionInferenceTask +from detection_tasks.apis.detection.ote_utils import TrainingProgressCallback +from detection_tasks.extension.utils.hooks import OTELoggerHook +from mmdet.apis.train import build_val_dataloader +from mmdet.datasets import build_dataloader, build_dataset +from mmdet.integration.nncf import check_nncf_is_enabled +from mmdet.integration.nncf import is_state_nncf +from mmdet.integration.nncf import wrap_nncf_model +from mmdet.integration.nncf import is_accuracy_aware_training_set +from mmdet.integration.nncf.config import compose_nncf_config +from mmdet.utils.logger import get_root_logger + + +logger = get_root_logger() + + +class OTEDetectionNNCFTask(OTEDetectionInferenceTask, IOptimizationTask): + + def __init__(self, task_environment: TaskEnvironment): + """" + Task for compressing object detection models using NNCF. + """ + self._val_dataloader = None + self._compression_ctrl = None + self._nncf_preset = "nncf_quantization" + check_nncf_is_enabled() + super().__init__(task_environment) + self._optimization_type = ModelOptimizationType.NNCF + + def _set_attributes_by_hyperparams(self): + quantization = self._hyperparams.nncf_optimization.enable_quantization + pruning = self._hyperparams.nncf_optimization.enable_pruning + if quantization and pruning: + self._nncf_preset = "nncf_quantization_pruning" + self._optimization_methods = [OptimizationMethod.QUANTIZATION, OptimizationMethod.FILTER_PRUNING] + self._precision = [ModelPrecision.INT8] + return + if quantization and not pruning: + self._nncf_preset = "nncf_quantization" + self._optimization_methods = [OptimizationMethod.QUANTIZATION] + self._precision = [ModelPrecision.INT8] + return + if not quantization and pruning: + self._nncf_preset = "nncf_pruning" + self._optimization_methods = [OptimizationMethod.FILTER_PRUNING] + self._precision = [ModelPrecision.FP32] + return + raise RuntimeError('Not selected optimization algorithm') + + def _load_model(self, model: ModelEntity): + # NNCF parts + nncf_config_path = os.path.join(self._base_dir, "compression_config.json") + + with open(nncf_config_path) as nncf_config_file: + common_nncf_config = json.load(nncf_config_file) + + self._set_attributes_by_hyperparams() + + optimization_config = compose_nncf_config(common_nncf_config, [self._nncf_preset]) + + max_acc_drop = self._hyperparams.nncf_optimization.maximal_accuracy_degradation / 100 + if "accuracy_aware_training" in optimization_config["nncf_config"]: + # Update maximal_absolute_accuracy_degradation + (optimization_config["nncf_config"]["accuracy_aware_training"] + ["params"]["maximal_absolute_accuracy_degradation"]) = max_acc_drop + # Force evaluation interval + self._config.evaluation.interval = 1 + else: + logger.info("NNCF config has no accuracy_aware_training parameters") + + self._config.update(optimization_config) + + compression_ctrl = None + if model is not None: + # If a model has been trained and saved for the task already, create empty model and load weights here + buffer = io.BytesIO(model.get_data("weights.pth")) + model_data = torch.load(buffer, map_location=torch.device('cpu')) + + self.confidence_threshold = model_data.get('confidence_threshold', + self._hyperparams.postprocessing.confidence_threshold) + if model_data.get('anchors'): + anchors = model_data['anchors'] + self._config.model.bbox_head.anchor_generator.heights = anchors['heights'] + self._config.model.bbox_head.anchor_generator.widths = anchors['widths'] + + model = self._create_model(self._config, from_scratch=True) + try: + if is_state_nncf(model_data): + compression_ctrl, model = wrap_nncf_model( + model, + self._config, + init_state_dict=model_data, + get_fake_input_func=get_fake_input + ) + logger.info("Loaded model weights from Task Environment and wrapped by NNCF") + else: + try: + model.load_state_dict(model_data['model']) + logger.info(f"Loaded model weights from Task Environment") + logger.info(f"Model architecture: {self._model_name}") + except BaseException as ex: + raise ValueError("Could not load the saved model. The model file structure is invalid.") \ + from ex + + logger.info(f"Loaded model weights from Task Environment") + logger.info(f"Model architecture: {self._model_name}") + except BaseException as ex: + raise ValueError("Could not load the saved model. The model file structure is invalid.") \ + from ex + else: + raise ValueError(f"No trained model in project. NNCF require pretrained weights to compress the model") + + self._compression_ctrl = compression_ctrl + return model + + def _create_compressed_model(self, dataset, config): + init_dataloader = build_dataloader( + dataset, + config.data.samples_per_gpu, + config.data.workers_per_gpu, + len(config.gpu_ids), + dist=False, + seed=config.seed) + is_acc_aware_training_set = is_accuracy_aware_training_set(config.get("nncf_config")) + + if is_acc_aware_training_set: + self._val_dataloader = build_val_dataloader(config, False) + + self._compression_ctrl, self._model = wrap_nncf_model( + self._model, + config, + val_dataloader=self._val_dataloader, + dataloader_for_init=init_dataloader, + get_fake_input_func=get_fake_input, + is_accuracy_aware=is_acc_aware_training_set) + + def optimize( + self, + optimization_type: OptimizationType, + dataset: DatasetEntity, + output_model: ModelEntity, + optimization_parameters: Optional[OptimizationParameters], + ): + if optimization_type is not OptimizationType.NNCF: + raise RuntimeError("NNCF is the only supported optimization") + + train_dataset = dataset.get_subset(Subset.TRAINING) + val_dataset = dataset.get_subset(Subset.VALIDATION) + + config = self._config + + if optimization_parameters is not None: + update_progress_callback = optimization_parameters.update_progress + else: + update_progress_callback = default_progress_callback + time_monitor = TrainingProgressCallback(update_progress_callback) + learning_curves = defaultdict(OTELoggerHook.Curve) + training_config = prepare_for_training(config, train_dataset, val_dataset, time_monitor, learning_curves) + mm_train_dataset = build_dataset(training_config.data.train) + + if torch.cuda.is_available(): + self._model.cuda(training_config.gpu_ids[0]) + + # Initialize NNCF parts if start from not compressed model + if not self._compression_ctrl: + self._create_compressed_model(mm_train_dataset, training_config) + + # Run training. + self._training_work_dir = training_config.work_dir + self._is_training = True + self._model.train() + + train_detector(model=self._model, + dataset=mm_train_dataset, + cfg=training_config, + validate=True, + val_dataloader=self._val_dataloader, + compression_ctrl=self._compression_ctrl) + + # Check for stop signal when training has stopped. If should_stop is true, training was cancelled + if self._should_stop: + logger.info('Training cancelled.') + self._should_stop = False + self._is_training = False + return + + self.save_model(output_model) + + output_model.model_format = ModelFormat.BASE_FRAMEWORK + output_model.optimization_type = self._optimization_type + output_model.optimization_methods = self._optimization_methods + output_model.precision = self._precision + + self._is_training = False + + def export(self, export_type: ExportType, output_model: ModelEntity): + if self._compression_ctrl is None: + super().export(export_type, output_model) + else: + self._compression_ctrl.prepare_for_export() + self._model.disable_dynamic_graph_building() + super().export(export_type, output_model) + self._model.enable_dynamic_graph_building() + + def save_model(self, output_model: ModelEntity): + buffer = io.BytesIO() + hyperparams = self._task_environment.get_hyper_parameters(OTEDetectionConfig) + hyperparams_str = ids_to_strings(cfg_helper.convert(hyperparams, dict, enum_to_str=True)) + labels = {label.name: label.color.rgb_tuple for label in self._labels} + # WA for scheduler resetting in NNCF + compression_state = self._compression_ctrl.get_compression_state() + for algo_state in compression_state.get('ctrl_state', {}).values(): + if not algo_state.get('scheduler_state'): + algo_state['scheduler_state'] = {'current_step': 0, 'current_epoch': 0} + modelinfo = { + 'compression_state': compression_state, + 'meta': { + 'config': self._config, + 'nncf_enable_compression': True, + }, + 'model': self._model.state_dict(), + 'config': hyperparams_str, + 'labels': labels, + 'confidence_threshold': self.confidence_threshold, + 'VERSION': 1, + } + + if hasattr(self._config.model, 'bbox_head') and hasattr(self._config.model.bbox_head, 'anchor_generator'): + if getattr(self._config.model.bbox_head.anchor_generator, 'reclustering_anchors', False): + generator = self._model.bbox_head.anchor_generator + modelinfo['anchors'] = {'heights': generator.heights, 'widths': generator.widths} + + torch.save(modelinfo, buffer) + output_model.set_data("weights.pth", buffer.getvalue()) + output_model.set_data("label_schema.json", label_schema_to_bytes(self._task_environment.label_schema)) diff --git a/external/mmdetection/detection_tasks/apis/detection/openvino_task.py b/external/mmdetection/detection_tasks/apis/detection/openvino_task.py new file mode 100644 index 00000000000..b8dd5d3fa61 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/openvino_task.py @@ -0,0 +1,376 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import attr +import copy +import inspect +import json +import numpy as np +import os +import ote_sdk.usecases.exportable_code.demo as demo +import subprocess # nosec +import sys +import tempfile +from addict import Dict as ADDict +from compression.api import DataLoader +from compression.engines.ie_engine import IEEngine +from compression.graph import load_model, save_model +from compression.graph.model_utils import compress_model_weights, get_nodes_by_type +from compression.pipeline.initializer import create_pipeline +from openvino.model_zoo.model_api.adapters import OpenvinoAdapter, create_core +from openvino.model_zoo.model_api.models import Model +from ote_sdk.entities.annotation import AnnotationSceneEntity +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.inference_parameters import InferenceParameters, default_progress_callback +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.model import ( + ModelEntity, + ModelFormat, + ModelOptimizationType, + ModelPrecision, + OptimizationMethod, +) +from ote_sdk.entities.model_template import TaskType +from ote_sdk.entities.optimization_parameters import OptimizationParameters +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.entities.task_environment import TaskEnvironment +from ote_sdk.serialization.label_mapper import LabelSchemaMapper, label_schema_to_bytes +from ote_sdk.usecases.evaluation.metrics_helper import MetricsHelper +from ote_sdk.usecases.exportable_code.inference import BaseInferencer +from ote_sdk.usecases.exportable_code.prediction_to_annotation_converter import ( + DetectionBoxToAnnotationConverter, + MaskToAnnotationConverter, + RotatedRectToAnnotationConverter, +) +from ote_sdk.usecases.tasks.interfaces.deployment_interface import IDeploymentTask +from ote_sdk.usecases.tasks.interfaces.evaluate_interface import IEvaluationTask +from ote_sdk.usecases.tasks.interfaces.inference_interface import IInferenceTask +from ote_sdk.usecases.tasks.interfaces.optimization_interface import IOptimizationTask, OptimizationType +from shutil import copyfile, copytree +from typing import Any, Dict, List, Optional, Tuple, Union +from zipfile import ZipFile + +from mmdet.utils.logger import get_root_logger +from . import model_wrappers +from .configuration import OTEDetectionConfig + +logger = get_root_logger() + + +class BaseInferencerWithConverter(BaseInferencer): + + def __init__(self, configuration, model, converter) -> None: + self.configuration = configuration + self.model = model + self.converter = converter + + def pre_process(self, image: np.ndarray) -> Tuple[Dict[str, np.ndarray], Dict[str, Any]]: + return self.model.preprocess(image) + + def post_process(self, prediction: Dict[str, np.ndarray], metadata: Dict[str, Any]) -> AnnotationSceneEntity: + detections = self.model.postprocess(prediction, metadata) + + return self.converter.convert_to_annotation(detections, metadata) + + def forward(self, inputs: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]: + return self.model.infer_sync(inputs) + + +class OpenVINODetectionInferencer(BaseInferencerWithConverter): + def __init__( + self, + hparams: OTEDetectionConfig, + label_schema: LabelSchemaEntity, + model_file: Union[str, bytes], + weight_file: Union[str, bytes, None] = None, + device: str = "CPU", + num_requests: int = 1, + ): + """ + Inferencer implementation for OTEDetection using OpenVINO backend. + + :param hparams: Hyper parameters that the model should use. + :param label_schema: LabelSchemaEntity that was used during model training. + :param model_file: Path OpenVINO IR model definition file. + :param weight_file: Path OpenVINO IR model weights file. + :param device: Device to run inference on, such as CPU, GPU or MYRIAD. Defaults to "CPU". + :param num_requests: Maximum number of requests that the inferencer can make. Defaults to 1. + + """ + + model_adapter = OpenvinoAdapter(create_core(), model_file, weight_file, device=device, max_num_requests=num_requests) + configuration = {**attr.asdict(hparams.postprocessing, + filter=lambda attr, value: attr.name not in ['header', 'description', 'type', 'visible_in_ui'])} + model = Model.create_model('ssd', model_adapter, configuration, preload=True) + converter = DetectionBoxToAnnotationConverter(label_schema) + + super().__init__(configuration, model, converter) + + +class OpenVINOMaskInferencer(BaseInferencerWithConverter): + def __init__( + self, + hparams: OTEDetectionConfig, + label_schema: LabelSchemaEntity, + model_file: Union[str, bytes], + weight_file: Union[str, bytes, None] = None, + device: str = "CPU", + num_requests: int = 1, + ): + model_adapter = OpenvinoAdapter( + create_core(), + model_file, + weight_file, + device=device, + max_num_requests=num_requests) + + configuration = { + **attr.asdict( + hparams.postprocessing, + filter=lambda attr, value: attr.name not in [ + 'header', 'description', 'type', 'visible_in_ui'])} + + model = Model.create_model( + 'maskrcnn', + model_adapter, + configuration, + preload=True) + + converter = MaskToAnnotationConverter(label_schema) + + super().__init__(configuration, model, converter) + + +class OpenVINORotatedRectInferencer(BaseInferencerWithConverter): + def __init__( + self, + hparams: OTEDetectionConfig, + label_schema: LabelSchemaEntity, + model_file: Union[str, bytes], + weight_file: Union[str, bytes, None] = None, + device: str = "CPU", + num_requests: int = 1, + ): + model_adapter = OpenvinoAdapter( + create_core(), + model_file, + weight_file, + device=device, + max_num_requests=num_requests) + + configuration = { + **attr.asdict( + hparams.postprocessing, + filter=lambda attr, value: attr.name not in [ + 'header', 'description', 'type', 'visible_in_ui'])} + + model = Model.create_model( + 'maskrcnn', + model_adapter, + configuration, + preload=True) + + converter = RotatedRectToAnnotationConverter(label_schema) + + super().__init__(configuration, model, converter) + + +class OTEOpenVinoDataLoader(DataLoader): + def __init__(self, dataset: DatasetEntity, inferencer: BaseInferencer): + self.dataset = dataset + self.inferencer = inferencer + + def __getitem__(self, index): + image = self.dataset[index].numpy + annotation = self.dataset[index].annotation_scene + inputs, metadata = self.inferencer.pre_process(image) + + return (index, annotation), inputs, metadata + + def __len__(self): + return len(self.dataset) + + +class OpenVINODetectionTask(IDeploymentTask, IInferenceTask, IEvaluationTask, IOptimizationTask): + def __init__(self, task_environment: TaskEnvironment): + logger.info('Loading OpenVINO OTEDetectionTask') + self.task_environment = task_environment + self.model = self.task_environment.model + self.task_type = self.task_environment.model_template.task_type + self.confidence_threshold: float = 0.0 + self.model_name = task_environment.model_template.model_template_id + self.inferencer = self.load_inferencer() + logger.info('OpenVINO task initialization completed') + + @property + def hparams(self): + return self.task_environment.get_hyper_parameters(OTEDetectionConfig) + + def load_inferencer(self) -> Union[OpenVINODetectionInferencer, OpenVINOMaskInferencer] : + _hparams = copy.deepcopy(self.hparams) + self.confidence_threshold = float(np.frombuffer(self.model.get_data("confidence_threshold"), dtype=np.float32)[0]) + _hparams.postprocessing.confidence_threshold = self.confidence_threshold + args = [ + _hparams, + self.task_environment.label_schema, + self.model.get_data("openvino.xml"), + self.model.get_data("openvino.bin"), + ] + if self.task_type == TaskType.DETECTION: + return OpenVINODetectionInferencer(*args) + if self.task_type == TaskType.INSTANCE_SEGMENTATION: + return OpenVINOMaskInferencer(*args) + if self.task_type == TaskType.ROTATED_DETECTION: + return OpenVINORotatedRectInferencer(*args) + raise RuntimeError(f"Unknown OpenVINO Inferencer TaskType: {self.task_type}") + + def infer(self, dataset: DatasetEntity, inference_parameters: Optional[InferenceParameters] = None) -> DatasetEntity: + logger.info('Start OpenVINO inference') + update_progress_callback = default_progress_callback + if inference_parameters is not None: + update_progress_callback = inference_parameters.update_progress + dataset_size = len(dataset) + for i, dataset_item in enumerate(dataset, 1): + predicted_scene = self.inferencer.predict(dataset_item.numpy) + dataset_item.append_annotations(predicted_scene.annotations) + update_progress_callback(int(i / dataset_size * 100)) + logger.info('OpenVINO inference completed') + return dataset + + def evaluate(self, + output_result_set: ResultSetEntity, + evaluation_metric: Optional[str] = None): + logger.info('Start OpenVINO metric evaluation') + if evaluation_metric is not None: + logger.warning(f'Requested to use {evaluation_metric} metric, but parameter is ignored. Use F-measure instead.') + output_result_set.performance = MetricsHelper.compute_f_measure(output_result_set).get_performance() + logger.info('OpenVINO metric evaluation completed') + + def deploy(self, + output_model: ModelEntity) -> None: + logger.info('Deploying the model') + + work_dir = os.path.dirname(demo.__file__) + model_file = inspect.getfile(type(self.inferencer.model)) + parameters = {} + parameters['type_of_model'] = self.inferencer.model.__model__ + parameters['converter_type'] = str(self.task_type) + parameters['model_parameters'] = self.inferencer.configuration + parameters['model_parameters']['labels'] = LabelSchemaMapper.forward(self.task_environment.label_schema) + name_of_package = "demo_package" + with tempfile.TemporaryDirectory() as tempdir: + copyfile(os.path.join(work_dir, "setup.py"), os.path.join(tempdir, "setup.py")) + copyfile(os.path.join(work_dir, "requirements.txt"), os.path.join(tempdir, "requirements.txt")) + copytree(os.path.join(work_dir, name_of_package), os.path.join(tempdir, name_of_package)) + config_path = os.path.join(tempdir, name_of_package, "config.json") + with open(config_path, "w", encoding='utf-8') as f: + json.dump(parameters, f, ensure_ascii=False, indent=4) + # generate model.py + if (inspect.getmodule(self.inferencer.model) in + [module[1] for module in inspect.getmembers(model_wrappers, inspect.ismodule)]): + copyfile(model_file, os.path.join(tempdir, name_of_package, "model.py")) + # create wheel package + subprocess.run([sys.executable, os.path.join(tempdir, "setup.py"), 'bdist_wheel', + '--dist-dir', tempdir, 'clean', '--all']) + wheel_file_name = [f for f in os.listdir(tempdir) if f.endswith('.whl')][0] + + with ZipFile(os.path.join(tempdir, "openvino.zip"), 'w') as zip: + zip.writestr(os.path.join("model", "model.xml"), self.model.get_data("openvino.xml")) + zip.writestr(os.path.join("model", "model.bin"), self.model.get_data("openvino.bin")) + zip.write(os.path.join(tempdir, "requirements.txt"), os.path.join("python", "requirements.txt")) + zip.write(os.path.join(work_dir, "README.md"), os.path.join("python", "README.md")) + zip.write(os.path.join(work_dir, "LICENSE"), os.path.join("python", "LICENSE")) + zip.write(os.path.join(work_dir, "demo.py"), os.path.join("python", "demo.py")) + zip.write(os.path.join(tempdir, wheel_file_name), os.path.join("python", wheel_file_name)) + with open(os.path.join(tempdir, "openvino.zip"), "rb") as file: + output_model.exportable_code = file.read() + logger.info('Deploying completed') + + def optimize(self, + optimization_type: OptimizationType, + dataset: DatasetEntity, + output_model: ModelEntity, + optimization_parameters: Optional[OptimizationParameters]): + logger.info('Start POT optimization') + + if optimization_type is not OptimizationType.POT: + raise ValueError('POT is the only supported optimization type for OpenVino models') + + data_loader = OTEOpenVinoDataLoader(dataset, self.inferencer) + + with tempfile.TemporaryDirectory() as tempdir: + xml_path = os.path.join(tempdir, "model.xml") + bin_path = os.path.join(tempdir, "model.bin") + with open(xml_path, "wb") as f: + f.write(self.model.get_data("openvino.xml")) + with open(bin_path, "wb") as f: + f.write(self.model.get_data("openvino.bin")) + + model_config = ADDict({ + 'model_name': 'openvino_model', + 'model': xml_path, + 'weights': bin_path + }) + + model = load_model(model_config) + + if get_nodes_by_type(model, ['FakeQuantize']): + raise RuntimeError("Model is already optimized by POT") + + engine_config = ADDict({ + 'device': 'CPU' + }) + + stat_subset_size = self.hparams.pot_parameters.stat_subset_size + preset = self.hparams.pot_parameters.preset.name.lower() + + algorithms = [ + { + 'name': 'DefaultQuantization', + 'params': { + 'target_device': 'ANY', + 'preset': preset, + 'stat_subset_size': min(stat_subset_size, len(data_loader)), + 'shuffle_data': True + } + } + ] + + engine = IEEngine(config=engine_config, data_loader=data_loader, metric=None) + + pipeline = create_pipeline(algorithms, engine) + + compressed_model = pipeline.run(model) + + compress_model_weights(compressed_model) + + with tempfile.TemporaryDirectory() as tempdir: + save_model(compressed_model, tempdir, model_name="model") + with open(os.path.join(tempdir, "model.xml"), "rb") as f: + output_model.set_data("openvino.xml", f.read()) + with open(os.path.join(tempdir, "model.bin"), "rb") as f: + output_model.set_data("openvino.bin", f.read()) + output_model.set_data("confidence_threshold", np.array([self.confidence_threshold], dtype=np.float32).tobytes()) + + output_model.set_data("label_schema.json", label_schema_to_bytes(self.task_environment.label_schema)) + + # set model attributes for quantized model + output_model.model_format = ModelFormat.OPENVINO + output_model.optimization_type = ModelOptimizationType.POT + output_model.optimization_methods = [OptimizationMethod.QUANTIZATION] + output_model.precision = [ModelPrecision.INT8] + + self.model = output_model + self.inferencer = self.load_inferencer() + logger.info('POT optimization completed') diff --git a/external/mmdetection/detection_tasks/apis/detection/ote_utils.py b/external/mmdetection/detection_tasks/apis/detection/ote_utils.py new file mode 100644 index 00000000000..2def0949b45 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/ote_utils.py @@ -0,0 +1,131 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import time +import colorsys +import importlib +import random +from typing import Callable, Union + +import numpy as np +import yaml +from ote_sdk.entities.color import Color +from ote_sdk.entities.id import ID +from ote_sdk.entities.label import Domain, LabelEntity +from ote_sdk.entities.label_schema import LabelGroup, LabelGroupType, LabelSchemaEntity +from ote_sdk.entities.train_parameters import UpdateProgressCallback +from ote_sdk.usecases.reporting.time_monitor_callback import TimeMonitorCallback + + +class ColorPalette: + def __init__(self, n, rng=None): + assert n > 0 + + if rng is None: + rng = random.Random(0xACE) + + candidates_num = 100 + hsv_colors = [(1.0, 1.0, 1.0)] + for _ in range(1, n): + colors_candidates = [(rng.random(), rng.uniform(0.8, 1.0), rng.uniform(0.5, 1.0)) + for _ in range(candidates_num)] + min_distances = [self.min_distance(hsv_colors, c) for c in colors_candidates] + arg_max = np.argmax(min_distances) + hsv_colors.append(colors_candidates[arg_max]) + + self.palette = [Color(*self.hsv2rgb(*hsv)) for hsv in hsv_colors] + + @staticmethod + def dist(c1, c2): + dh = min(abs(c1[0] - c2[0]), 1 - abs(c1[0] - c2[0])) * 2 + ds = abs(c1[1] - c2[1]) + dv = abs(c1[2] - c2[2]) + return dh * dh + ds * ds + dv * dv + + @classmethod + def min_distance(cls, colors_set, color_candidate): + distances = [cls.dist(o, color_candidate) for o in colors_set] + return np.min(distances) + + @staticmethod + def hsv2rgb(h, s, v): + return tuple(round(c * 255) for c in colorsys.hsv_to_rgb(h, s, v)) + + def __getitem__(self, n): + return self.palette[n % len(self.palette)] + + def __len__(self): + return len(self.palette) + + +def generate_label_schema(label_names, label_domain=Domain.DETECTION): + colors = ColorPalette(len(label_names)) if len(label_names) > 0 else [] + not_empty_labels = [LabelEntity(name=name, color=colors[i], domain=label_domain, id=ID(f"{i:08}")) for i, name in + enumerate(label_names)] + emptylabel = LabelEntity(name=f"Empty label", color=Color(42, 43, 46), + is_empty=True, domain=label_domain, id=ID(f"{len(not_empty_labels):08}")) + + label_schema = LabelSchemaEntity() + exclusive_group = LabelGroup(name="labels", labels=not_empty_labels, group_type=LabelGroupType.EXCLUSIVE) + empty_group = LabelGroup(name="empty", labels=[emptylabel], group_type=LabelGroupType.EMPTY_LABEL) + label_schema.add_group(exclusive_group) + label_schema.add_group(empty_group) + return label_schema + + +def load_template(path): + with open(path) as f: + template = yaml.full_load(f) + return template + + +def get_task_class(path): + module_name, class_name = path.rsplit('.', 1) + module = importlib.import_module(module_name) + return getattr(module, class_name) + + +class TrainingProgressCallback(TimeMonitorCallback): + def __init__(self, update_progress_callback: Union[UpdateProgressCallback, Callable[[int], None]]): + super().__init__(0, 0, 0, 0, update_progress_callback=update_progress_callback) + + def on_train_batch_end(self, batch, logs=None): + super().on_train_batch_end(batch, logs) + self.update_progress_callback(int(self.get_progress())) + + def on_epoch_end(self, epoch, logs=None): + self.past_epoch_duration.append(time.time() - self.start_epoch_time) + self._calculate_average_epoch() + score = None + if hasattr(self.update_progress_callback, 'metric') and isinstance(logs, dict): + score = logs.get(self.update_progress_callback.metric, None) + # Workaround for NNCF trainer, which uses callback of a different type. + if score is not None: + self.update_progress_callback(self.get_progress(), score=float(score)) + else: + self.update_progress_callback(int(self.get_progress())) + + +class InferenceProgressCallback(TimeMonitorCallback): + def __init__(self, num_test_steps, update_progress_callback: Callable[[int], None]): + super().__init__( + num_epoch=0, + num_train_steps=0, + num_val_steps=0, + num_test_steps=num_test_steps, + update_progress_callback=update_progress_callback) + + def on_test_batch_end(self, batch=None, logs=None): + super().on_test_batch_end(batch, logs) + self.update_progress_callback(int(self.get_progress())) diff --git a/external/mmdetection/detection_tasks/apis/detection/train_task.py b/external/mmdetection/detection_tasks/apis/detection/train_task.py new file mode 100644 index 00000000000..9d837cd2f82 --- /dev/null +++ b/external/mmdetection/detection_tasks/apis/detection/train_task.py @@ -0,0 +1,224 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import copy +import io +import os +from collections import defaultdict +from glob import glob +from typing import List, Optional + +import numpy as np +import torch +from ote_sdk.configuration import cfg_helper +from ote_sdk.configuration.helper.utils import ids_to_strings +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.metrics import (BarChartInfo, BarMetricsGroup, CurveMetric, LineChartInfo, LineMetricsGroup, MetricsGroup, + ScoreMetric, VisualizationType) +from ote_sdk.entities.model import ModelEntity, ModelPrecision +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.entities.subset import Subset +from ote_sdk.entities.train_parameters import TrainParameters, default_progress_callback +from ote_sdk.serialization.label_mapper import label_schema_to_bytes +from ote_sdk.usecases.evaluation.metrics_helper import MetricsHelper +from ote_sdk.usecases.tasks.interfaces.training_interface import ITrainingTask + +from mmdet.apis import train_detector +from detection_tasks.apis.detection.config_utils import cluster_anchors, prepare_for_training, set_hyperparams +from detection_tasks.apis.detection.inference_task import OTEDetectionInferenceTask +from detection_tasks.apis.detection.ote_utils import TrainingProgressCallback +from detection_tasks.extension.utils.hooks import OTELoggerHook +from mmdet.datasets import build_dataset +from mmdet.utils.logger import get_root_logger + +logger = get_root_logger() + + +class OTEDetectionTrainingTask(OTEDetectionInferenceTask, ITrainingTask): + + def _generate_training_metrics(self, learning_curves, map) -> Optional[List[MetricsGroup]]: + """ + Parses the mmdetection logs to get metrics from the latest training run + + :return output List[MetricsGroup] + """ + output: List[MetricsGroup] = [] + + # Learning curves. + for key, curve in learning_curves.items(): + n, m = len(curve.x), len(curve.y) + if n != m: + logger.warning(f"Learning curve {key} has inconsistent number of coordinates ({n} vs {m}.") + n = min(n, m) + curve.x = curve.x[:n] + curve.y = curve.y[:n] + metric_curve = CurveMetric( + xs=np.nan_to_num(curve.x).tolist(), + ys=np.nan_to_num(curve.y).tolist(), + name=key) + visualization_info = LineChartInfo(name=key, x_axis_label="Epoch", y_axis_label=key) + output.append(LineMetricsGroup(metrics=[metric_curve], visualization_info=visualization_info)) + + # Final mAP value on the validation set. + output.append( + BarMetricsGroup( + metrics=[ScoreMetric(value=map, name="mAP")], + visualization_info=BarChartInfo("Validation score", visualization_type=VisualizationType.RADIAL_BAR) + ) + ) + + return output + + + def train(self, dataset: DatasetEntity, output_model: ModelEntity, train_parameters: Optional[TrainParameters] = None): + """ Trains a model on a dataset """ + + logger.info('Training the model') + set_hyperparams(self._config, self._hyperparams) + + train_dataset = dataset.get_subset(Subset.TRAINING) + val_dataset = dataset.get_subset(Subset.VALIDATION) + + # Do clustering for SSD model + if hasattr(self._config.model, 'bbox_head') and hasattr(self._config.model.bbox_head, 'anchor_generator'): + if getattr(self._config.model.bbox_head.anchor_generator, 'reclustering_anchors', False): + self._config, self._model = cluster_anchors(self._config, train_dataset, self._model) + + config = self._config + + # Create a copy of the network. + old_model = copy.deepcopy(self._model) + + # Check for stop signal between pre-eval and training. If training is cancelled at this point, + # old_model should be restored. + if self._should_stop: + logger.info('Training cancelled.') + self._model = old_model + self._should_stop = False + self._is_training = False + self._training_work_dir = None + return + + # Run training. + update_progress_callback = default_progress_callback + if train_parameters is not None: + update_progress_callback = train_parameters.update_progress + time_monitor = TrainingProgressCallback(update_progress_callback) + learning_curves = defaultdict(OTELoggerHook.Curve) + training_config = prepare_for_training(config, train_dataset, val_dataset, time_monitor, learning_curves) + self._training_work_dir = training_config.work_dir + mm_train_dataset = build_dataset(training_config.data.train) + self._is_training = True + self._model.train() + logger.info('Start training') + train_detector(model=self._model, dataset=mm_train_dataset, cfg=training_config, validate=True) + logger.info('Training completed') + + # Check for stop signal when training has stopped. If should_stop is true, training was cancelled and no new + # model should be returned. Old train model is restored. + if self._should_stop: + logger.info('Training cancelled.') + self._model = old_model + self._should_stop = False + self._is_training = False + return + + # Load best weights. + checkpoint_file_path = glob(os.path.join(training_config.work_dir, 'best*pth')) + if len(checkpoint_file_path) == 0: + checkpoint_file_path = os.path.join(training_config.work_dir, 'latest.pth') + elif len(checkpoint_file_path) > 1: + logger.warning(f'Multiple candidates for the best checkpoint found: {checkpoint_file_path}') + checkpoint_file_path = checkpoint_file_path[0] + else: + checkpoint_file_path = checkpoint_file_path[0] + logger.info(f'Use {checkpoint_file_path} for final model weights.') + checkpoint = torch.load(checkpoint_file_path) + self._model.load_state_dict(checkpoint['state_dict']) + + # Get predictions on the validation set. + val_preds, val_map = self._infer_detector( + self._model, + config, + val_dataset, + metric_name=config.evaluation.metric, + dump_features=False, + eval=True + ) + preds_val_dataset = val_dataset.with_empty_annotations() + self._add_predictions_to_dataset(val_preds, preds_val_dataset, 0.0) + resultset = ResultSetEntity( + model=output_model, + ground_truth_dataset=val_dataset, + prediction_dataset=preds_val_dataset, + ) + + # Adjust confidence threshold. + adaptive_threshold = self._hyperparams.postprocessing.result_based_confidence_threshold + if adaptive_threshold: + logger.info('Adjusting the confidence threshold') + metric = MetricsHelper.compute_f_measure(resultset, vary_confidence_threshold=True) + best_confidence_threshold = metric.best_confidence_threshold.value + if best_confidence_threshold is None: + raise ValueError(f"Cannot compute metrics: Invalid confidence threshold!") + logger.info(f"Setting confidence threshold to {best_confidence_threshold} based on results") + self.confidence_threshold = best_confidence_threshold + else: + metric = MetricsHelper.compute_f_measure(resultset, vary_confidence_threshold=False) + + # Compose performance statistics. + # TODO[EUGENE]: ADD MAE CURVE FOR TaskType.COUNTING + performance = metric.get_performance() + performance.dashboard_metrics.extend(self._generate_training_metrics(learning_curves, val_map)) + logger.info(f'Final model performance: {str(performance)}') + + # Save resulting model. + self.save_model(output_model) + output_model.performance = performance + + self._is_training = False + logger.info('Training the model [done]') + + + def save_model(self, output_model: ModelEntity): + buffer = io.BytesIO() + hyperparams_str = ids_to_strings(cfg_helper.convert(self._hyperparams, dict, enum_to_str=True)) + + modelinfo = {'model': self._model.state_dict(), + 'config': hyperparams_str, + 'confidence_threshold': self.confidence_threshold, + 'VERSION': 1} + + if hasattr(self._config.model, 'bbox_head') and hasattr(self._config.model.bbox_head, 'anchor_generator'): + if getattr(self._config.model.bbox_head.anchor_generator, 'reclustering_anchors', False): + generator = self._model.bbox_head.anchor_generator + modelinfo['anchors'] = {'heights': generator.heights, 'widths': generator.widths} + + torch.save(modelinfo, buffer) + output_model.set_data("weights.pth", buffer.getvalue()) + output_model.set_data("label_schema.json", label_schema_to_bytes(self._task_environment.label_schema)) + output_model.precision = [ModelPrecision.FP32] + + + def cancel_training(self): + """ + Sends a cancel training signal to gracefully stop the optimizer. The signal consists of creating a + '.stop_training' file in the current work_dir. The runner checks for this file periodically. + The stopping mechanism allows stopping after each iteration, but validation will still be carried out. Stopping + will therefore take some time. + """ + logger.info("Cancel training requested.") + self._should_stop = True + stop_training_filepath = os.path.join(self._training_work_dir, '.stop_training') + open(stop_training_filepath, 'a').close() diff --git a/external/mmdetection/detection_tasks/extension/__init__.py b/external/mmdetection/detection_tasks/extension/__init__.py new file mode 100644 index 00000000000..90eb8894330 --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/__init__.py @@ -0,0 +1,17 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from .datasets import OTEDataset, get_annotation_mmdet_format +from .utils import (CancelTrainingHook, FixedMomentumUpdaterHook, LoadImageFromOTEDataset, EpochRunnerWithCancel, + LoadAnnotationFromOTEDataset, OTELoggerHook, OTEProgressHook, EarlyStoppingHook, ReduceLROnPlateauLrUpdaterHook) diff --git a/external/mmdetection/detection_tasks/extension/datasets/__init__.py b/external/mmdetection/detection_tasks/extension/datasets/__init__.py new file mode 100644 index 00000000000..e9bc5ab37d1 --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/datasets/__init__.py @@ -0,0 +1,18 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from .data_utils import get_anchor_boxes, get_sizes_from_dataset_entity, format_list_to_str +from .mmdataset import OTEDataset, get_annotation_mmdet_format + +__all__ = [OTEDataset, get_annotation_mmdet_format, get_anchor_boxes, get_sizes_from_dataset_entity, format_list_to_str] diff --git a/external/mmdetection/detection_tasks/extension/datasets/data_utils.py b/external/mmdetection/detection_tasks/extension/datasets/data_utils.py new file mode 100644 index 00000000000..ff38a3243af --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/datasets/data_utils.py @@ -0,0 +1,390 @@ +# Copyright (C) 2020-2021 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# +import json +import os.path as osp +from typing import List, Optional + +import numpy as np +from ote_sdk.entities.annotation import Annotation, AnnotationSceneEntity, AnnotationSceneKind +from ote_sdk.entities.dataset_item import DatasetItemEntity +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.id import ID +from ote_sdk.entities.image import Image +from ote_sdk.entities.label import Domain, LabelEntity +from ote_sdk.entities.scored_label import ScoredLabel +from ote_sdk.entities.shapes.polygon import Polygon, Point +from ote_sdk.entities.shapes.rectangle import Rectangle +from ote_sdk.entities.subset import Subset +from ote_sdk.utils.shape_factory import ShapeFactory +from pycocotools.coco import COCO + +from mmdet.core import BitmapMasks, PolygonMasks + +def get_classes_from_annotation(path): + with open(path) as read_file: + content = json.load(read_file) + categories = [ + v["name"] for v in sorted(content["categories"], key=lambda x: x["id"]) + ] + return categories + + +class LoadAnnotations: + def __init__(self, with_bbox=True, with_label=True, with_mask=False): + self.with_bbox = with_bbox + self.with_label = with_label + self.with_mask = with_mask + + def _load_bboxes(self, results): + ann_info = results["ann_info"] + results["gt_bboxes"] = ann_info["bboxes"].copy() + + gt_bboxes_ignore = ann_info.get("bboxes_ignore", None) + if gt_bboxes_ignore is not None: + results["gt_bboxes_ignore"] = gt_bboxes_ignore.copy() + results["bbox_fields"].append("gt_bboxes_ignore") + results["bbox_fields"].append("gt_bboxes") + return results + + def _load_labels(self, results): + results["gt_labels"] = results["ann_info"]["labels"].copy() + return results + + def _load_masks(self, results): + gt_masks = results['ann_info']['masks'] + results['gt_masks'] = gt_masks + results['mask_fields'].append('gt_masks') + return results + + def __call__(self, results): + if self.with_bbox: + results = self._load_bboxes(results) + if results is None: + return None + if self.with_label: + results = self._load_labels(results) + if self.with_mask: + results = self._load_masks(results) + + return results + + def __repr__(self): + repr_str = self.__class__.__name__ + repr_str += f"(with_bbox={self.with_bbox}, " + repr_str += f"with_label={self.with_label})" + return repr_str + + +class CocoDataset: + def __init__( + self, + ann_file, + classes=None, + data_root=None, + img_prefix="", + test_mode=False, + filter_empty_gt=True, + min_size=None, + with_mask=False, + ): + self.ann_file = ann_file + self.data_root = data_root + self.img_prefix = img_prefix + self.test_mode = test_mode + self.filter_empty_gt = filter_empty_gt + self.classes = self.get_classes(classes) + self.min_size = min_size + self.with_mask = with_mask + + if self.data_root is not None: + # if not osp.isabs(self.ann_file): + # self.ann_file = osp.join(self.data_root, self.ann_file) + if not (self.img_prefix is None or osp.isabs(self.img_prefix)): + self.img_prefix = osp.join(self.data_root, self.img_prefix) + + self.data_infos = self.load_annotations(self.ann_file) + + if not test_mode: + valid_inds = self._filter_imgs() + self.data_infos = [self.data_infos[i] for i in valid_inds] + + def __len__(self): + return len(self.data_infos) + + def pre_pipeline(self, results): + results["img_prefix"] = self.img_prefix + results["bbox_fields"] = [] + results["mask_fields"] = [] + results["seg_fields"] = [] + + def _rand_another(self, idx): + pool = np.where(self.flag == self.flag[idx])[0] + return np.random.choice(pool) + + def __getitem__(self, idx): + return self.prepare_img(idx) + + def __iter__(self): + for i in range(len(self)): + yield self[i] + + def prepare_img(self, idx): + img_info = self.data_infos[idx] + ann_info = self.get_ann_info(idx) + results = dict(img_info=img_info, ann_info=ann_info) + self.pre_pipeline(results) + return LoadAnnotations(with_mask=self.with_mask)(results) + + def get_classes(self, classes=None): + if classes is None: + return get_classes_from_annotation(self.ann_file) + + if isinstance(classes, (tuple, list)): + return classes + + raise ValueError(f"Unsupported type {type(classes)} of classes.") + + def load_annotations(self, ann_file): + self.coco = COCO(ann_file) + self.cat_ids = self.coco.get_cat_ids(cat_names=self.classes) + self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)} + self.img_ids = self.coco.get_img_ids() + data_infos = [] + for i in self.img_ids: + info = self.coco.load_imgs([i])[0] + info["filename"] = info["file_name"] + data_infos.append(info) + return data_infos + + def get_ann_info(self, idx): + img_id = self.data_infos[idx]["id"] + ann_ids = self.coco.get_ann_ids(img_ids=[img_id]) + ann_info = self.coco.load_anns(ann_ids) + return self._parse_ann_info(self.data_infos[idx], ann_info) + + def get_cat_ids(self, idx): + img_id = self.data_infos[idx]["id"] + ann_ids = self.coco.get_ann_ids(img_ids=[img_id]) + ann_info = self.coco.load_anns(ann_ids) + return [ann["category_id"] for ann in ann_info] + + def _filter_imgs(self, min_size=32): + """Filter images too small or without ground truths.""" + valid_inds = [] + # obtain images that contain annotation + ids_with_ann = set(_["image_id"] for _ in self.coco.anns.values()) + # obtain images that contain annotations of the required categories + ids_in_cat = set() + for i, class_id in enumerate(self.cat_ids): + ids_in_cat |= set(self.coco.cat_img_map[class_id]) + # merge the image id sets of the two conditions and use the merged set + # to filter out images if self.filter_empty_gt=True + ids_in_cat &= ids_with_ann + + valid_img_ids = [] + for i, img_info in enumerate(self.data_infos): + img_id = self.img_ids[i] + if self.filter_empty_gt and img_id not in ids_in_cat: + continue + if min(img_info["width"], img_info["height"]) >= min_size: + valid_inds.append(i) + valid_img_ids.append(img_id) + self.img_ids = valid_img_ids + return valid_inds + + def _parse_ann_info(self, img_info, ann_info): + gt_bboxes = [] + gt_labels = [] + gt_bboxes_ignore = [] + gt_masks_ann = [] + for ann in ann_info: + if ann.get("ignore", False): + continue + x1, y1, w, h = ann["bbox"] + inter_w = max(0, min(x1 + w, img_info["width"]) - max(x1, 0)) + inter_h = max(0, min(y1 + h, img_info["height"]) - max(y1, 0)) + if inter_w * inter_h == 0: + continue + if ann["area"] <= 0 or w < 1 or h < 1: + continue + if self.min_size is not None: + if w < self.min_size or h < self.min_size: + continue + if ann["category_id"] not in self.cat_ids: + continue + bbox = [x1, y1, x1 + w, y1 + h] + if ann.get("iscrowd", False): + gt_bboxes_ignore.append(bbox) + else: + gt_bboxes.append(bbox) + gt_labels.append(self.cat2label[ann["category_id"]]) + gt_masks_ann.append(ann.get("segmentation", None)) + + if gt_bboxes: + gt_bboxes = np.array(gt_bboxes, dtype=np.float32) + gt_labels = np.array(gt_labels, dtype=np.int64) + else: + gt_bboxes = np.zeros((0, 4), dtype=np.float32) + gt_labels = np.array([], dtype=np.int64) + + if gt_bboxes_ignore: + gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32) + else: + gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32) + + seg_map = img_info["filename"].replace("jpg", "png") + + ann = dict( + bboxes=gt_bboxes, + labels=gt_labels, + bboxes_ignore=gt_bboxes_ignore, + masks=gt_masks_ann, + seg_map=seg_map, + ) + + return ann + + +def find_label_by_name(labels, name, domain): + matching_labels = [label for label in labels if label.name == name] + if len(matching_labels) == 1: + return matching_labels[0] + elif len(matching_labels) == 0: + label = LabelEntity(name=name, domain=domain, id=ID(len(labels))) + labels.append(label) + return label + else: + raise ValueError("Found multiple matching labels") + + +def load_dataset_items_coco_format( + ann_file_path: str, + data_root_dir: str, + domain: Domain, + subset: Subset = Subset.NONE, + labels_list: Optional[List[LabelEntity]] = None, + with_mask: bool = False, +): + test_mode = subset in {Subset.VALIDATION, Subset.TESTING} + + coco_dataset = CocoDataset( + ann_file=ann_file_path, + data_root=data_root_dir, + classes=None, + test_mode=test_mode, + with_mask=with_mask, + ) + coco_dataset.test_mode = False + for label_name in coco_dataset.classes: + find_label_by_name(labels_list, label_name, domain) + + dataset_items = [] + for item in coco_dataset: + + def create_gt_box(x1, y1, x2, y2, label_name): + return Annotation( + Rectangle(x1=x1, y1=y1, x2=x2, y2=y2), + labels=[ScoredLabel(label=find_label_by_name(labels_list, label_name, domain))], + ) + + def create_gt_polygon(polygon_group, label_name): + if len(polygon_group) != 1: + raise RuntimeError("Complex instance segmentation masks consisting of several polygons are not supported.") + + return Annotation( + Polygon(points=polygon_group[0]), + labels=[ScoredLabel(label=find_label_by_name(labels_list, label_name, domain))], + ) + + img_height = item["img_info"].get("height") + img_width = item["img_info"].get("width") + divisor = np.array( + [img_width, img_height, img_width, img_height], + dtype=item["gt_bboxes"].dtype, + ) + bboxes = item["gt_bboxes"] / divisor + labels = item["gt_labels"] + + assert len(bboxes) == len(labels) + if with_mask: + polygons = item["gt_masks"] + assert len(bboxes) == len(polygons) + normalized_polygons = [] + for polygon_group in polygons: + normalized_polygons.append([]) + for polygon in polygon_group: + normalized_polygon = [p / divisor[i % 2] for i, p in enumerate(polygon)] + points = [Point(normalized_polygon[i], normalized_polygon[i + 1]) for i in range(0, len(polygon), 2)] + normalized_polygons[-1].append(points) + + if item["img_prefix"] is not None: + filename = osp.join(item["img_prefix"], item["img_info"]["filename"]) + else: + filename = item["img_info"]["filename"] + + if with_mask: + shapes = [ + create_gt_polygon(polygon_group, coco_dataset.classes[label_id]) + for polygon_group, label_id in zip(normalized_polygons, labels) + ] + else: + shapes = [ + create_gt_box(x1, y1, x2, y2, coco_dataset.classes[label_id]) + for (x1, y1, x2, y2), label_id in zip(bboxes, labels) + ] + + dataset_item = DatasetItemEntity( + media=Image(file_path=filename), + annotation_scene=AnnotationSceneEntity( + annotations=shapes, kind=AnnotationSceneKind.ANNOTATION + ), + subset=subset, + ) + dataset_items.append(dataset_item) + + return dataset_items + + +def get_sizes_from_dataset_entity(dataset: DatasetEntity, target_wh: list): + """ + Function to get sizes of instances in DatasetEntity and to resize it to the target size. + + :param dataset: DatasetEntity in which to get statistics + :param target_wh: target width and height of the dataset + :return list: tuples with width and height of each instance + """ + wh_stats = [] + for item in dataset: + for ann in item.get_annotations(include_empty=False): + has_detection_labels = any(label.domain == Domain.DETECTION for label in ann.get_labels(include_empty=False)) + if has_detection_labels: + box = ShapeFactory.shape_as_rectangle(ann.shape) + w = box.width * target_wh[0] + h = box.height * target_wh[1] + wh_stats.append((w, h)) + return wh_stats + + +def get_anchor_boxes(wh_stats, group_as): + from sklearn.cluster import KMeans + kmeans = KMeans(init='k-means++', n_clusters=sum(group_as), random_state=0).fit(wh_stats) + centers = kmeans.cluster_centers_ + + areas = np.sqrt(np.prod(centers, axis=1)) + idx = np.argsort(areas) + + widths = centers[idx, 0] + heights = centers[idx, 1] + + group_as = np.cumsum(group_as[:-1]) + widths, heights = np.split(widths, group_as), np.split(heights, group_as) + return widths, heights + + +def format_list_to_str(value_lists): + """ Decrease floating point digits in logs """ + str_value = '' + for value_list in value_lists: + str_value += '[' + ', '.join(f'{value:.2f}' for value in value_list) + '], ' + return f'[{str_value[:-2]}]' diff --git a/external/mmdetection/detection_tasks/extension/datasets/mmdataset.py b/external/mmdetection/detection_tasks/extension/datasets/mmdataset.py new file mode 100644 index 00000000000..ba7ef08c136 --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/datasets/mmdataset.py @@ -0,0 +1,214 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from copy import deepcopy +from typing import List + +import numpy as np +from ote_sdk.entities.dataset_item import DatasetItemEntity +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.label import Domain, LabelEntity +from ote_sdk.utils.shape_factory import ShapeFactory + +from mmdet.core import PolygonMasks +from mmdet.datasets.builder import DATASETS +from mmdet.datasets.custom import CustomDataset +from mmdet.datasets.pipelines import Compose + + +def get_annotation_mmdet_format( + dataset_item: DatasetItemEntity, + labels: List[LabelEntity], + domain: Domain, + min_size: int = -1, +) -> dict: + """ + Function to convert a OTE annotation to mmdetection format. This is used both in the OTEDataset class defined in + this file as in the custom pipeline element 'LoadAnnotationFromOTEDataset' + + :param dataset_item: DatasetItem for which to get annotations + :param labels: List of labels that are used in the task + :return dict: annotation information dict in mmdet format + """ + width, height = dataset_item.width, dataset_item.height + + # load annotations for item + gt_bboxes = [] + gt_labels = [] + gt_polygons = [] + + label_idx = {label.id: i for i, label in enumerate(labels)} + + for annotation in dataset_item.get_annotations(labels=labels, include_empty=False): + + box = ShapeFactory.shape_as_rectangle(annotation.shape) + + if min(box.width * width, box.height * height) < min_size: + continue + + class_indices = [ + label_idx[label.id] + for label in annotation.get_labels(include_empty=False) + if label.domain == domain + ] + + n = len(class_indices) + gt_bboxes.extend([[box.x1 * width, box.y1 * height, box.x2 * width, box.y2 * height] for _ in range(n)]) + if domain != Domain.DETECTION: + polygon = ShapeFactory.shape_as_polygon(annotation.shape) + polygon = np.array([p for point in polygon.points for p in [point.x * width, point.y * height]]) + gt_polygons.extend([[polygon] for _ in range(n)]) + gt_labels.extend(class_indices) + + if len(gt_bboxes) > 0: + ann_info = dict( + bboxes=np.array(gt_bboxes, dtype=np.float32).reshape(-1, 4), + labels=np.array(gt_labels, dtype=int), + masks=PolygonMasks( + gt_polygons, height=height, width=width) if gt_polygons else []) + else: + ann_info = dict( + bboxes=np.zeros((0, 4), dtype=np.float32), + labels=np.array([], dtype=int), + masks=[]) + return ann_info + + +@DATASETS.register_module() +class OTEDataset(CustomDataset): + """ + Wrapper that allows using a OTE dataset to train mmdetection models. This wrapper is not based on the filesystem, + but instead loads the items here directly from the OTE DatasetEntity object. + + The wrapper overwrites some methods of the CustomDataset class: prepare_train_img, prepare_test_img and prepipeline + Naming of certain attributes might seem a bit peculiar but this is due to the conventions set in CustomDataset. For + instance, CustomDatasets expects the dataset items to be stored in the attribute data_infos, which is why it is + named like that and not dataset_items. + + """ + + class _DataInfoProxy: + """ + This class is intended to be a wrapper to use it in CustomDataset-derived class as `self.data_infos`. + Instead of using list `data_infos` as in CustomDataset, our implementation of dataset OTEDataset + uses this proxy class with overriden __len__ and __getitem__; this proxy class + forwards data access operations to ote_dataset and converts the dataset items to the view + convenient for mmdetection. + """ + def __init__(self, ote_dataset, labels): + self.ote_dataset = ote_dataset + self.labels = labels + + def __len__(self): + return len(self.ote_dataset) + + def __getitem__(self, index): + """ + Prepare a dict 'data_info' that is expected by the mmdet pipeline to handle images and annotations + :return data_info: dictionary that contains the image and image metadata, as well as the labels of the objects + in the image + """ + + dataset = self.ote_dataset + item = dataset[index] + + height, width = item.height, item.width + + data_info = dict(dataset_item=item, width=width, height=height, index=index, + ann_info=dict(label_list=self.labels)) + + return data_info + + def __init__(self, ote_dataset: DatasetEntity, labels: List[LabelEntity], pipeline, domain, test_mode: bool = False): + self.ote_dataset = ote_dataset + self.labels = labels + self.CLASSES = list(label.name for label in labels) + self.domain = domain + self.test_mode = test_mode + + # Instead of using list data_infos as in CustomDataset, this implementation of dataset + # uses a proxy class with overriden __len__ and __getitem__; this proxy class + # forwards data access operations to ote_dataset. + # Note that list `data_infos` cannot be used here, since OTE dataset class does not have interface to + # get only annotation of a data item, so we would load the whole data item (including image) + # even if we need only checking aspect ratio of the image; due to it + # this implementation of dataset does not uses such tricks as skipping images with wrong aspect ratios or + # small image size, since otherwise reading the whole dataset during initialization will be required. + self.data_infos = OTEDataset._DataInfoProxy(ote_dataset, labels) + + self.proposals = None # Attribute expected by mmdet but not used for OTE datasets + + if not test_mode: + self._set_group_flag() + + self.pipeline = Compose(pipeline) + + def _set_group_flag(self): + """Set flag for grouping images. + + Originally, in Custom dataset, images with aspect ratio greater than 1 will be set as group 1, + otherwise group 0. + This implementation will set group 0 for every image. + """ + self.flag = np.zeros(len(self), dtype=np.uint8) + + def _rand_another(self, idx): + return np.random.choice(len(self)) + + # In contrast with CustomDataset this implementation of dataset + # does not filter images w.r.t. the min size + def _filter_imgs(self, min_size=32): + raise NotImplementedError + + def prepare_train_img(self, idx: int) -> dict: + """Get training data and annotations after pipeline. + + :param idx: int, Index of data. + :return dict: Training data and annotation after pipeline with new keys introduced by pipeline. + """ + item = deepcopy(self.data_infos[idx]) + self.pre_pipeline(item) + return self.pipeline(item) + + def prepare_test_img(self, idx: int) -> dict: + """Get testing data after pipeline. + + :param idx: int, Index of data. + :return dict: Testing data after pipeline with new keys introduced by pipeline. + """ + # FIXME. + # item = deepcopy(self.data_infos[idx]) + item = self.data_infos[idx] + self.pre_pipeline(item) + return self.pipeline(item) + + @staticmethod + def pre_pipeline(results: dict): + """Prepare results dict for pipeline. Add expected keys to the dict. """ + results['bbox_fields'] = [] + results['mask_fields'] = [] + results['seg_fields'] = [] + + def get_ann_info(self, idx): + """ + This method is used for evaluation of predictions. The CustomDataset class implements a method + CustomDataset.evaluate, which uses the class method get_ann_info to retrieve annotations. + + :param idx: index of the dataset item for which to get the annotations + :return ann_info: dict that contains the coordinates of the bboxes and their corresponding labels + """ + dataset_item = self.ote_dataset[idx] + labels = self.labels + return get_annotation_mmdet_format(dataset_item, labels, self.domain) + diff --git a/external/mmdetection/detection_tasks/extension/utils/__init__.py b/external/mmdetection/detection_tasks/extension/utils/__init__.py new file mode 100644 index 00000000000..144196cf57b --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/utils/__init__.py @@ -0,0 +1,22 @@ +# Copyright (C) 2021-2022 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from .hooks import CancelTrainingHook, FixedMomentumUpdaterHook, OTELoggerHook, OTEProgressHook +from .hooks import EarlyStoppingHook, ReduceLROnPlateauLrUpdaterHook, StopLossNanTrainingHook +from .pipelines import LoadImageFromOTEDataset, LoadAnnotationFromOTEDataset +from .runner import EpochRunnerWithCancel + +__all__ = [CancelTrainingHook, FixedMomentumUpdaterHook, LoadImageFromOTEDataset, EpochRunnerWithCancel, + LoadAnnotationFromOTEDataset, OTELoggerHook, OTEProgressHook, EarlyStoppingHook, + ReduceLROnPlateauLrUpdaterHook, StopLossNanTrainingHook] diff --git a/external/mmdetection/detection_tasks/extension/utils/hooks.py b/external/mmdetection/detection_tasks/extension/utils/hooks.py new file mode 100644 index 00000000000..3c6cc4846f9 --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/utils/hooks.py @@ -0,0 +1,502 @@ +# Copyright (C) 2021-2022 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import logging +import math +import os +from math import inf, isnan +from collections import defaultdict + +from mmcv.runner.hooks import HOOKS, Hook, LoggerHook, LrUpdaterHook +from mmcv.runner import BaseRunner, EpochBasedRunner +from mmcv.runner.dist_utils import master_only +from mmcv.utils import print_log + +from mmdet.utils.logger import get_root_logger + + +logger = get_root_logger() + + +@HOOKS.register_module() +class CancelTrainingHook(Hook): + def __init__(self, interval: int = 5): + """ + Periodically check whether whether a stop signal is sent to the runner during model training. + Every 'check_interval' iterations, the work_dir for the runner is checked to see if a file '.stop_training' + is present. If it is, training is stopped. + + :param interval: Period for checking for stop signal, given in iterations. + + """ + self.interval = interval + + @staticmethod + def _check_for_stop_signal(runner: BaseRunner): + work_dir = runner.work_dir + stop_filepath = os.path.join(work_dir, '.stop_training') + if os.path.exists(stop_filepath): + if isinstance(runner, EpochBasedRunner): + epoch = runner.epoch + runner._max_epochs = epoch # Force runner to stop by pretending it has reached it's max_epoch + runner.should_stop = True # Set this flag to true to stop the current training epoch + os.remove(stop_filepath) + + def after_train_iter(self, runner: BaseRunner): + if not self.every_n_iters(runner, self.interval): + return + self._check_for_stop_signal(runner) + + +@HOOKS.register_module() +class FixedMomentumUpdaterHook(Hook): + def __init__(self): + """ + This hook does nothing, as the momentum is fixed by default. The hook is here to streamline switching between + different LR schedules. + """ + pass + + def before_run(self, runner): + pass + + +@HOOKS.register_module() +class EnsureCorrectBestCheckpointHook(Hook): + def __init__(self): + """ + This hook makes sure that the 'best_mAP' checkpoint points properly to the best model, even if the best model is + created in the last epoch. + """ + pass + + def after_run(self, runner): + runner.call_hook('after_train_epoch') + + +@HOOKS.register_module() +class OTELoggerHook(LoggerHook): + + class Curve: + def __init__(self): + self.x = [] + self.y = [] + + def __repr__(self): + points = [] + for x, y in zip(self.x, self.y): + points.append(f'({x},{y})') + return 'curve[' + ','.join(points) + ']' + + def __init__(self, + curves=None, + interval=10, + ignore_last=True, + reset_flag=True, + by_epoch=True): + super().__init__(interval, ignore_last, reset_flag, by_epoch) + self.curves = curves if curves is not None else defaultdict(self.Curve) + + @master_only + def log(self, runner): + tags = self.get_loggable_tags(runner, allow_text=False) + if runner.max_epochs is not None: + normalized_iter = self.get_iter(runner) / runner.max_iters * runner.max_epochs + else: + normalized_iter = self.get_iter(runner) + for tag, value in tags.items(): + curve = self.curves[tag] + # Remove duplicates. + if len(curve.x) > 0 and curve.x[-1] == normalized_iter: + curve.x.pop() + curve.y.pop() + curve.x.append(normalized_iter) + curve.y.append(value) + + def after_train_epoch(self, runner): + # Iteration counter is increased right after the last iteration in the epoch, + # temporarily decrease it back. + runner._iter -= 1 + super().after_train_epoch(runner) + runner._iter += 1 + + +@HOOKS.register_module() +class OTEProgressHook(Hook): + def __init__(self, time_monitor, verbose=False): + super().__init__() + self.time_monitor = time_monitor + self.verbose = verbose + self.print_threshold = 1 + + def before_run(self, runner): + total_epochs = runner.max_epochs if runner.max_epochs is not None else 1 + self.time_monitor.total_epochs = total_epochs + self.time_monitor.train_steps = runner.max_iters // total_epochs if total_epochs else 1 + self.time_monitor.steps_per_epoch = self.time_monitor.train_steps + self.time_monitor.val_steps + self.time_monitor.total_steps = max(math.ceil(self.time_monitor.steps_per_epoch * total_epochs), 1) + self.time_monitor.current_step = 0 + self.time_monitor.current_epoch = 0 + + def before_epoch(self, runner): + self.time_monitor.on_epoch_begin(runner.epoch) + + def after_epoch(self, runner): + self.time_monitor.on_epoch_end(runner.epoch, runner.log_buffer.output) + + def before_iter(self, runner): + self.time_monitor.on_train_batch_begin(1) + + def after_iter(self, runner): + self.time_monitor.on_train_batch_end(1) + if self.verbose: + progress = self.progress + if progress >= self.print_threshold: + logger.warning(f'training progress {progress:.0f}%') + self.print_threshold = (progress + 10) // 10 * 10 + + def before_val_iter(self, runner): + self.time_monitor.on_test_batch_begin(1) + + def after_val_iter(self, runner): + self.time_monitor.on_test_batch_end(1) + + def after_run(self, runner): + self.time_monitor.on_train_end(1) + self.time_monitor.update_progress_callback(int(self.time_monitor.get_progress())) + + @property + def progress(self): + return self.time_monitor.get_progress() + + +@HOOKS.register_module() +class EarlyStoppingHook(Hook): + """ + Cancel training when a metric has stopped improving. + + Early Stopping hook monitors a metric quantity and if no improvement is seen for a ‘patience’ + number of epochs, the training is cancelled. + + :param interval: the number of intervals for checking early stop. The interval number should be + the same as the evaluation interval - the `interval` variable set in + `evaluation` config. + :param metric: the metric name to be monitored + :param rule: greater or less. In `less` mode, training will stop when the metric has stopped + decreasing and in `greater` mode it will stop when the metric has stopped + increasing. + :param patience: Number of epochs with no improvement after which the training will be reduced. + For example, if patience = 2, then we will ignore the first 2 epochs with no + improvement, and will only cancel the training after the 3rd epoch if the + metric still hasn’t improved then + :param iteration_patience: Number of iterations must be trained after the last improvement + before training stops. The same as patience but the training + continues if the number of iteration is lower than iteration_patience + This variable makes sure a model is trained enough for some + iterations after the last improvement before stopping. + :param min_delta: Minimal decay applied to lr. If the difference between new and old lr is + smaller than eps, the update is ignored + """ + rule_map = {'greater': lambda x, y: x > y, 'less': lambda x, y: x < y} + init_value_map = {'greater': -inf, 'less': inf} + greater_keys = [ + 'acc', 'top', 'AR@', 'auc', 'precision', 'mAP', 'mDice', 'mIoU', + 'mAcc', 'aAcc' + ] + less_keys = ['loss'] + + def __init__(self, + interval: int, + metric: str = 'bbox_mAP', + rule: str = None, + patience: int = 5, + iteration_patience: int = 500, + min_delta: float = 0.0): + super().__init__() + self.patience = patience + self.iteration_patience = iteration_patience + self.interval = interval + self.min_delta = min_delta + self._init_rule(rule, metric) + + self.min_delta *= 1 if self.rule == 'greater' else -1 + self.last_iter = 0 + self.wait_count = 0 + self.best_score = self.init_value_map[self.rule] + + def _init_rule(self, rule, key_indicator): + """Initialize rule, key_indicator, comparison_func, and best score. + + Here is the rule to determine which rule is used for key indicator + when the rule is not specific: + 1. If the key indicator is in ``self.greater_keys``, the rule will be + specified as 'greater'. + 2. Or if the key indicator is in ``self.less_keys``, the rule will be + specified as 'less'. + 3. Or if the key indicator is equal to the substring in any one item + in ``self.greater_keys``, the rule will be specified as 'greater'. + 4. Or if the key indicator is equal to the substring in any one item + in ``self.less_keys``, the rule will be specified as 'less'. + + Args: + rule (str | None): Comparison rule for best score. + key_indicator (str | None): Key indicator to determine the + comparison rule. + """ + if rule not in self.rule_map and rule is not None: + raise KeyError(f'rule must be greater, less or None, ' + f'but got {rule}.') + + if rule is None: + if key_indicator in self.greater_keys or any( + key in key_indicator for key in self.greater_keys): + rule = 'greater' + elif key_indicator in self.less_keys or any( + key in key_indicator for key in self.less_keys): + rule = 'less' + else: + raise ValueError(f'Cannot infer the rule for key ' + f'{key_indicator}, thus a specific rule ' + f'must be specified.') + self.rule = rule + self.key_indicator = key_indicator + self.compare_func = self.rule_map[self.rule] + + def before_run(self, runner): + self.by_epoch = False if runner.max_epochs is None else True + for hook in runner.hooks: + if isinstance(hook, LrUpdaterHook): + self.warmup_iters = hook.warmup_iters + break + + def after_train_iter(self, runner): + """Called after every training iter to evaluate the results.""" + if not self.by_epoch: + self._do_check_stopping(runner) + + def after_train_epoch(self, runner): + """Called after every training epoch to evaluate the results.""" + if self.by_epoch: + self._do_check_stopping(runner) + + def _do_check_stopping(self, runner): + if not self._should_check_stopping( + runner) or self.warmup_iters > runner.iter: + return + + if runner.rank == 0: + if self.key_indicator not in runner.log_buffer.output: + raise KeyError( + f'metric {self.key_indicator} does not exist in buffer. Please check ' + f'{self.key_indicator} is cached in evaluation output buffer' + ) + + key_score = runner.log_buffer.output[self.key_indicator] + if self.compare_func(key_score - self.min_delta, self.best_score): + self.best_score = key_score + self.wait_count = 0 + self.last_iter = runner.iter + else: + self.wait_count += 1 + if self.wait_count >= self.patience: + if runner.iter - self.last_iter < self.iteration_patience: + print_log( + f"\nSkip early stopping. Accumulated iteration " + f"{runner.iter - self.last_iter} from the last " + f"improvement must be larger than {self.iteration_patience} to trigger " + f"Early Stopping.", + logger=runner.logger) + return + stop_point = runner.epoch if self.by_epoch else runner.iter + print_log( + f"\nEarly Stopping at :{stop_point} with " + f"best {self.key_indicator}: {self.best_score}", + logger=runner.logger) + runner.should_stop = True + + def _should_check_stopping(self, runner): + check_time = self.every_n_epochs if self.by_epoch else self.every_n_iters + if not check_time(runner, self.interval): + # No evaluation during the interval. + return False + return True + + +@HOOKS.register_module() +class ReduceLROnPlateauLrUpdaterHook(LrUpdaterHook): + """ + Reduce learning rate when a metric has stopped improving. + + Models often benefit from reducing the learning rate by a factor of 2-10 once learning stagnates. + This scheduler reads a metrics quantity and if no improvement is seen for a ‘patience’ + number of epochs, the learning rate is reduced. + + :param min_lr: minimum learning rate. The lower bound of the desired learning rate. + :param interval: the number of intervals for checking the hook. The interval number should be + the same as the evaluation interval - the `interval` variable set in + `evaluation` config. + :param metric: the metric name to be monitored + :param rule: greater or less. In `less` mode, learning rate will be dropped if the metric has + stopped decreasing and in `greater` mode it will be dropped when the metric has + stopped increasing. + :param patience: Number of epochs with no improvement after which learning rate will be reduced. + For example, if patience = 2, then we will ignore the first 2 epochs with no + improvement, and will only drop LR after the 3rd epoch if the metric still + hasn’t improved then + :param iteration_patience: Number of iterations must be trained after the last improvement + before LR drops. The same as patience but the LR remains the same if + the number of iteration is lower than iteration_patience. This + variable makes sure a model is trained enough for some iterations + after the last improvement before dropping the LR. + :param factor: Factor to be multiply with the learning rate. + For example, new_lr = current_lr * factor + """ + rule_map = {'greater': lambda x, y: x > y, 'less': lambda x, y: x < y} + init_value_map = {'greater': -inf, 'less': inf} + greater_keys = [ + 'acc', 'top', 'AR@', 'auc', 'precision', 'mAP', 'mDice', 'mIoU', + 'mAcc', 'aAcc' + ] + less_keys = ['loss'] + + def __init__(self, + min_lr, + interval, + metric='bbox_mAP', + rule=None, + factor=0.1, + patience=3, + iteration_patience=300, + **kwargs): + super().__init__(**kwargs) + self.interval = interval + self.min_lr = min_lr + self.factor = factor + self.patience = patience + self.iteration_patience = iteration_patience + self.metric = metric + self.bad_count = 0 + self.last_iter = 0 + self.current_lr = None + self._init_rule(rule, metric) + self.best_score = self.init_value_map[self.rule] + + def _init_rule(self, rule, key_indicator): + """Initialize rule, key_indicator, comparison_func, and best score. + + Here is the rule to determine which rule is used for key indicator + when the rule is not specific: + 1. If the key indicator is in ``self.greater_keys``, the rule will be + specified as 'greater'. + 2. Or if the key indicator is in ``self.less_keys``, the rule will be + specified as 'less'. + 3. Or if the key indicator is equal to the substring in any one item + in ``self.greater_keys``, the rule will be specified as 'greater'. + 4. Or if the key indicator is equal to the substring in any one item + in ``self.less_keys``, the rule will be specified as 'less'. + + Args: + rule (str | None): Comparison rule for best score. + key_indicator (str | None): Key indicator to determine the + comparison rule. + """ + if rule not in self.rule_map and rule is not None: + raise KeyError(f'rule must be greater, less or None, ' + f'but got {rule}.') + + if rule is None: + if key_indicator in self.greater_keys or any( + key in key_indicator for key in self.greater_keys): + rule = 'greater' + elif key_indicator in self.less_keys or any( + key in key_indicator for key in self.less_keys): + rule = 'less' + else: + raise ValueError(f'Cannot infer the rule for key ' + f'{key_indicator}, thus a specific rule ' + f'must be specified.') + self.rule = rule + self.key_indicator = key_indicator + self.compare_func = self.rule_map[self.rule] + + def _should_check_stopping(self, runner): + check_time = self.every_n_epochs if self.by_epoch else self.every_n_iters + if not check_time(runner, self.interval): + # No evaluation during the interval. + return False + return True + + def get_lr(self, runner, base_lr): + if not self._should_check_stopping( + runner) or self.warmup_iters > runner.iter: + return base_lr + + if self.current_lr is None: + self.current_lr = base_lr + + if hasattr(runner, self.metric): + score = getattr(runner, self.metric, 0.0) + else: + return self.current_lr + + print_log( + f"\nBest Score: {self.best_score}, Current Score: {score}, Patience: {self.patience} " + f"Count: {self.bad_count}", + logger=runner.logger) + if self.compare_func(score, self.best_score): + self.best_score = score + self.bad_count = 0 + self.last_iter = runner.iter + else: + self.bad_count += 1 + + if self.bad_count >= self.patience: + if runner.iter - self.last_iter < self.iteration_patience: + print_log( + f"\nSkip LR dropping. Accumulated iteration " + f"{runner.iter - self.last_iter} from the last " + f"improvement must be larger than {self.iteration_patience} to trigger " + f"LR dropping.", + logger=runner.logger) + return self.current_lr + self.last_iter = runner.iter + self.bad_count = 0 + print_log( + f"\nDrop LR from: {self.current_lr}, to: " + f"{max(self.current_lr * self.factor, self.min_lr)}", + logger=runner.logger) + self.current_lr = max(self.current_lr * self.factor, self.min_lr) + return self.current_lr + + def before_run(self, runner): + # TODO: remove overloaded method after fixing the issue + # https://github.com/open-mmlab/mmdetection/issues/6572 + for group in runner.optimizer.param_groups: + group.setdefault('initial_lr', group['lr']) + self.base_lr = [ + group['lr'] for group in runner.optimizer.param_groups + ] + self.bad_count = 0 + self.last_iter = 0 + self.current_lr = None + self.best_score = self.init_value_map[self.rule] + + +@HOOKS.register_module() +class StopLossNanTrainingHook(Hook): + + def after_train_iter(self, runner): + if isnan(runner.outputs['loss'].item()): + logger.warning(f"Early Stopping since loss is NaN") + runner.should_stop = True diff --git a/external/mmdetection/detection_tasks/extension/utils/pipelines.py b/external/mmdetection/detection_tasks/extension/utils/pipelines.py new file mode 100644 index 00000000000..82629e49973 --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/utils/pipelines.py @@ -0,0 +1,120 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import copy + +import numpy as np + +from mmdet.datasets.builder import PIPELINES + +from ..datasets import get_annotation_mmdet_format + + +@PIPELINES.register_module() +class LoadImageFromOTEDataset: + """ + Pipeline element that loads an image from a OTE Dataset on the fly. Can do conversion to float 32 if needed. + + Expected entries in the 'results' dict that should be passed to this pipeline element are: + results['dataset_item']: dataset_item from which to load the image + results['dataset_id']: id of the dataset to which the item belongs + results['index']: index of the item in the dataset + + :param to_float32: optional bool, True to convert images to fp32. defaults to False + """ + + def __init__(self, to_float32: bool = False): + self.to_float32 = to_float32 + + def __call__(self, results): + dataset_item = results['dataset_item'] + img = dataset_item.numpy + shape = img.shape + + assert img.shape[0] == results['height'], f"{img.shape[0]} != {results['height']}" + assert img.shape[1] == results['width'], f"{img.shape[1]} != {results['width']}" + + filename = f"Dataset item index {results['index']}" + results['filename'] = filename + results['ori_filename'] = filename + results['img'] = img + results['img_shape'] = shape + results['ori_shape'] = shape + # Set initial values for default meta_keys + results['pad_shape'] = shape + num_channels = 1 if len(shape) < 3 else shape[2] + results['img_norm_cfg'] = dict( + mean=np.zeros(num_channels, dtype=np.float32), + std=np.ones(num_channels, dtype=np.float32), + to_rgb=False) + results['img_fields'] = ['img'] + + if self.to_float32: + results['img'] = results['img'].astype(np.float32) + + return results + + +@PIPELINES.register_module() +class LoadAnnotationFromOTEDataset: + """ + Pipeline element that loads an annotation from a OTE Dataset on the fly. + + Expected entries in the 'results' dict that should be passed to this pipeline element are: + results['dataset_item']: dataset_item from which to load the annotation + results['ann_info']['label_list']: list of all labels in the project + + """ + + def __init__(self, min_size : int, with_bbox: bool = True, with_label: bool = True, with_mask: bool = False, with_seg: bool = False, + poly2mask: bool = True, with_text: bool = False, domain=None): + self.with_bbox = with_bbox + self.with_label = with_label + self.with_mask = with_mask + self.with_seg = with_seg + self.poly2mask = poly2mask + self.with_text = with_text + self.domain = domain + self.min_size = min_size + + @staticmethod + def _load_bboxes(results, ann_info): + results['bbox_fields'].append('gt_bboxes') + results['gt_bboxes'] = copy.deepcopy(ann_info['bboxes']) + return results + + @staticmethod + def _load_labels(results, ann_info): + results['gt_labels'] = copy.deepcopy(ann_info['labels']) + return results + + @staticmethod + def _load_masks(results, ann_info): + results['mask_fields'].append('gt_masks') + results['gt_masks'] = copy.deepcopy(ann_info['masks']) + return results + + def __call__(self, results): + dataset_item = results['dataset_item'] + label_list = results['ann_info']['label_list'] + ann_info = get_annotation_mmdet_format(dataset_item, label_list, self.domain, self.min_size) + if self.with_bbox: + results = self._load_bboxes(results, ann_info) + if results is None or len(results['gt_bboxes']) == 0: + return None + if self.with_label: + results = self._load_labels(results, ann_info) + if self.with_mask: + results = self._load_masks(results, ann_info) + return results diff --git a/external/mmdetection/detection_tasks/extension/utils/runner.py b/external/mmdetection/detection_tasks/extension/utils/runner.py new file mode 100644 index 00000000000..94889b2d1d2 --- /dev/null +++ b/external/mmdetection/detection_tasks/extension/utils/runner.py @@ -0,0 +1,127 @@ +# Copyright (c) 2018-2021 OpenMMLab +# SPDX-License-Identifier: Apache-2.0 +# +# Copyright (C) 2020-2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +# Is based on +# * https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/epoch_based_runner.py +# * https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/iter_based_runner.py + +import time +import warnings + +import mmcv +import torch.distributed as dist +from mmcv.runner.utils import get_host_info +from mmcv.runner import RUNNERS, EpochBasedRunner, IterBasedRunner, IterLoader, get_dist_info + + +@RUNNERS.register_module() +class EpochRunnerWithCancel(EpochBasedRunner): + """ + Simple modification to EpochBasedRunner to allow cancelling the training during an epoch. + A stopping hook should set the runner.should_stop flag to True if stopping is required. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.should_stop = False + _, world_size = get_dist_info() + self.distributed = True if world_size > 1 else False + + def stop(self) -> bool: + """ Returning a boolean to break the training loop + This method supports distributed training by broadcasting should_stop to other ranks + :return: a cancellation bool + """ + broadcast_obj = [False] + if self.rank == 0 and self.should_stop: + broadcast_obj = [True] + + if self.distributed: + dist.broadcast_object_list(broadcast_obj, src=0) + if broadcast_obj[0]: + self._max_epochs = self.epoch + return broadcast_obj[0] + + def train(self, data_loader, **kwargs): + self.model.train() + self.mode = 'train' + self.data_loader = data_loader + self._max_iters = self._max_epochs * len(self.data_loader) + self.call_hook('before_train_epoch') + time.sleep(2) # Prevent possible deadlock during epoch transition + for i, data_batch in enumerate(self.data_loader): + self._inner_iter = i + self.call_hook('before_train_iter') + self.run_iter(data_batch, train_mode=True, **kwargs) + self.call_hook('after_train_iter') + if self.stop(): + break + self._iter += 1 + self.call_hook('after_train_epoch') + self.stop() + self._epoch += 1 + + +@RUNNERS.register_module() +class IterBasedRunnerWithCancel(IterBasedRunner): + """ + Simple modification to IterBasedRunner to allow cancelling the training. The cancel training hook + should set the runner.should_stop flag to True if stopping is required. + + # TODO: Implement cancelling of training via keyboard interrupt signal, instead of should_stop + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.should_stop = False + + def main_loop(self, workflow, iter_loaders, **kwargs): + while self.iter < self._max_iters: + for i, flow in enumerate(workflow): + self._inner_iter = 0 + mode, iters = flow + if not isinstance(mode, str) or not hasattr(self, mode): + raise ValueError( + 'runner has no method named "{}" to run a workflow'. + format(mode)) + iter_runner = getattr(self, mode) + for _ in range(iters): + if mode == 'train' and self.iter >= self._max_iters: + break + iter_runner(iter_loaders[i], **kwargs) + if self.should_stop: + return + + def run(self, data_loaders, workflow, max_iters=None, **kwargs): + assert isinstance(data_loaders, list) + assert mmcv.is_list_of(workflow, tuple) + assert len(data_loaders) == len(workflow) + if max_iters is not None: + warnings.warn( + 'setting max_iters in run is deprecated, ' + 'please set max_iters in runner_config', DeprecationWarning) + self._max_iters = max_iters + assert self._max_iters is not None, ( + 'max_iters must be specified during instantiation') + + work_dir = self.work_dir if self.work_dir is not None else 'NONE' + self.logger.info('Start running, host: %s, work_dir: %s', + get_host_info(), work_dir) + self.logger.info('workflow: %s, max: %d iters', workflow, + self._max_iters) + self.call_hook('before_run') + + iter_loaders = [IterLoader(x) for x in data_loaders] + + self.call_hook('before_epoch') + + self.should_stop = False + self.main_loop(workflow, iter_loaders, **kwargs) + self.should_stop = False + + time.sleep(1) # wait for some hooks like loggers to finish + self.call_hook('after_epoch') + self.call_hook('after_run') diff --git a/external/mmdetection/detection_tasks/sample/sample.py b/external/mmdetection/detection_tasks/sample/sample.py new file mode 100644 index 00000000000..c9f22057e22 --- /dev/null +++ b/external/mmdetection/detection_tasks/sample/sample.py @@ -0,0 +1,205 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import argparse +import sys + +import numpy as np +from mmcv.utils import get_logger +from ote_sdk.configuration.helper import create +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.id import ID +from ote_sdk.entities.inference_parameters import InferenceParameters +from ote_sdk.entities.label import Domain +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.model import ModelEntity +from ote_sdk.entities.model_template import parse_model_template +from ote_sdk.entities.optimization_parameters import OptimizationParameters +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.entities.subset import Subset +from ote_sdk.entities.task_environment import TaskEnvironment +from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType +from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType + +from detection_tasks.apis.detection.ote_utils import get_task_class + + +logger = get_logger(name='sample') + + +def parse_args(): + parser = argparse.ArgumentParser(description='Sample showcasing the new API') + parser.add_argument('template_file_path', help='path to template file') + parser.add_argument('--export', action='store_true') + return parser.parse_args() + + +def load_test_dataset(): + from ote_sdk.entities.annotation import Annotation, AnnotationSceneEntity, AnnotationSceneKind + from ote_sdk.entities.dataset_item import DatasetItemEntity + from ote_sdk.entities.image import Image + from ote_sdk.entities.label import LabelEntity + from ote_sdk.entities.scored_label import ScoredLabel + from ote_sdk.entities.shapes.rectangle import Rectangle + from ote_sdk.entities.subset import Subset + + def gen_image(resolution, x1, y1, x2, y2): + w, h = resolution + image = np.full([h, w, 3], fill_value=255, dtype=np.uint8) + image[int(y1 * h):int(y2 * h), int(x1 * w):int(x2 * w), :] = np.array([0, 128, 128], dtype=np.uint8)[None, None, :] + return (image, Rectangle(x1=x1, y1=y1, x2=x2, y2=y2)) + + images = [ + gen_image((640, 480), 0.0, 0.0, 0.5, 0.5), + gen_image((640, 480), 0.5, 0.0, 1.0, 0.5), + gen_image((640, 480), 0.0, 0.5, 0.5, 1.0), + gen_image((640, 480), 0.5, 0.5, 1.0, 1.0), + ] + labels = [ + LabelEntity(name='rect', domain=Domain.DETECTION, id=ID(f"{0:08}")) + ] + + def get_image(i, subset): + image, bbox = images[i] + return DatasetItemEntity( + media=Image(data=image), + annotation_scene=AnnotationSceneEntity( + annotations=[Annotation(bbox, labels=[ScoredLabel(label=labels[0])])], + kind=AnnotationSceneKind.ANNOTATION + ), + subset=subset, + ) + + items = [ + get_image(0, Subset.TRAINING), + get_image(1, Subset.TRAINING), + get_image(2, Subset.TRAINING), + get_image(3, Subset.TRAINING), + get_image(0, Subset.TRAINING), + get_image(1, Subset.TRAINING), + get_image(2, Subset.TRAINING), + get_image(3, Subset.TRAINING), + get_image(0, Subset.TRAINING), + get_image(1, Subset.TRAINING), + get_image(0, Subset.VALIDATION), + get_image(1, Subset.VALIDATION), + get_image(2, Subset.VALIDATION), + get_image(3, Subset.VALIDATION), + get_image(0, Subset.TESTING), + get_image(1, Subset.TESTING), + get_image(2, Subset.TESTING), + get_image(3, Subset.TESTING), + ] + return DatasetEntity(items), labels + + +def main(args): + logger.info('Initialize dataset') + dataset, labels_list = load_test_dataset() + labels_schema = LabelSchemaEntity.from_labels(labels_list) + + logger.info(f'Train dataset: {len(dataset.get_subset(Subset.TRAINING))} items') + logger.info(f'Validation dataset: {len(dataset.get_subset(Subset.VALIDATION))} items') + + logger.info('Load model template') + model_template = parse_model_template(args.template_file_path) + + logger.info('Set hyperparameters') + params = create(model_template.hyper_parameters.data) + params.learning_parameters.num_iters = 5 + params.learning_parameters.learning_rate_warmup_iters = 1 + params.learning_parameters.batch_size = 2 + + logger.info('Setup environment') + environment = TaskEnvironment(model=None, hyper_parameters=params, label_schema=labels_schema, model_template=model_template) + + logger.info('Create base Task') + task_impl_path = model_template.entrypoints.base + task_cls = get_task_class(task_impl_path) + task = task_cls(task_environment=environment) + + logger.info('Train model') + output_model = ModelEntity( + dataset, + environment.get_model_configuration(), + ) + task.train(dataset, output_model) + + logger.info('Get predictions on the validation set') + validation_dataset = dataset.get_subset(Subset.VALIDATION) + predicted_validation_dataset = task.infer( + validation_dataset.with_empty_annotations(), + InferenceParameters(is_evaluation=True)) + resultset = ResultSetEntity( + model=output_model, + ground_truth_dataset=validation_dataset, + prediction_dataset=predicted_validation_dataset, + ) + logger.info('Estimate quality on validation set') + task.evaluate(resultset) + logger.info(str(resultset.performance)) + + if args.export: + logger.info('Export model') + exported_model = ModelEntity( + dataset, + environment.get_model_configuration(), + ) + task.export(ExportType.OPENVINO, exported_model) + + logger.info('Create OpenVINO Task') + environment.model = exported_model + openvino_task_impl_path = model_template.entrypoints.openvino + openvino_task_cls = get_task_class(openvino_task_impl_path) + openvino_task = openvino_task_cls(environment) + + logger.info('Get predictions on the validation set') + predicted_validation_dataset = openvino_task.infer( + validation_dataset.with_empty_annotations(), + InferenceParameters(is_evaluation=True)) + resultset = ResultSetEntity( + model=output_model, + ground_truth_dataset=validation_dataset, + prediction_dataset=predicted_validation_dataset, + ) + logger.info('Estimate quality on validation set') + openvino_task.evaluate(resultset) + logger.info(str(resultset.performance)) + + logger.info('Run POT optimization') + optimized_model = ModelEntity( + dataset, + environment.get_model_configuration(), + ) + openvino_task.optimize( + OptimizationType.POT, + dataset.get_subset(Subset.TRAINING), + optimized_model, + OptimizationParameters()) + + logger.info('Get predictions on the validation set') + predicted_validation_dataset = openvino_task.infer( + validation_dataset.with_empty_annotations(), + InferenceParameters(is_evaluation=True)) + resultset = ResultSetEntity( + model=optimized_model, + ground_truth_dataset=validation_dataset, + prediction_dataset=predicted_validation_dataset, + ) + logger.info('Performance of optimized model:') + openvino_task.evaluate(resultset) + logger.info(str(resultset.performance)) + +if __name__ == '__main__': + sys.exit(main(parse_args()) or 0) diff --git a/external/mmdetection/init_venv.sh b/external/mmdetection/init_venv.sh new file mode 100755 index 00000000000..ca8c467e249 --- /dev/null +++ b/external/mmdetection/init_venv.sh @@ -0,0 +1,134 @@ +#!/usr/bin/env bash +# Copyright (C) 2020-2021 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# +set -v +set -x + +work_dir=$(realpath "$(dirname $0)") + +venv_dir=$1 +PYTHON_NAME=$2 + +if [ -z "$venv_dir" ]; then + venv_dir=$(realpath -m ${work_dir}/venv) +else + venv_dir=$(realpath -m "$venv_dir") +fi + +if [[ -z $PYTHON_NAME ]]; then + # the default option -- note that the minimal version of + # python that is suitable for this repo is python3.7, + # whereas the default python3 may point to python3.6 + PYTHON_NAME=python3 +fi + +PYTHON_VERSION=$($PYTHON_NAME --version | sed -e "s/^Python \([0-9]\.[0-9]\)\..*/\1/") || exit 1 +if [[ $PYTHON_VERSION != "3.7" && $PYTHON_VERSION != "3.8" && $PYTHON_VERSION != "3.9" ]]; then + echo "Wrong version of python: '$PYTHON_VERSION'" + exit 1 +fi + +cd ${work_dir} + +if [[ -e ${venv_dir} ]]; then + echo + echo "Virtualenv already exists. Use command to start working:" + echo "$ . ${venv_dir}/bin/activate" + exit +fi + +# Create virtual environment +$PYTHON_NAME -m venv ${venv_dir} --prompt="detection" + +if ! [ -e "${venv_dir}/bin/activate" ]; then + echo "The virtual environment was not created." + exit +fi + +. ${venv_dir}/bin/activate + +# Get CUDA version. +CUDA_HOME_CANDIDATE=/usr/local/cuda +if [ -z "${CUDA_HOME}" ] && [ -d ${CUDA_HOME_CANDIDATE} ]; then + echo "Exporting CUDA_HOME as ${CUDA_HOME_CANDIDATE}" + export CUDA_HOME=${CUDA_HOME_CANDIDATE} +fi + +if [ -e "$CUDA_HOME" ]; then + if [ -e "$CUDA_HOME/version.txt" ]; then + # Get CUDA version from version.txt file. + CUDA_VERSION=$(cat $CUDA_HOME/version.txt | sed -e "s/^.*CUDA Version *//" -e "s/ .*//") + else + # Get CUDA version from directory name. + CUDA_HOME_DIR=`readlink -f $CUDA_HOME` + CUDA_HOME_DIR=`basename $CUDA_HOME_DIR` + CUDA_VERSION=`echo $CUDA_HOME_DIR | cut -d "-" -f 2` + fi +fi + +# install PyTorch and MMCV. +export TORCH_VERSION=1.8.2 +export TORCHVISION_VERSION=0.9.2 +export MMCV_VERSION=1.3.14 + +if [[ -z ${CUDA_VERSION} ]]; then + echo "CUDA was not found, installing dependencies in CPU-only mode. If you want to use CUDA, set CUDA_HOME and CUDA_VERSION beforehand." +else + # Remove dots from CUDA version string, if any. + CUDA_VERSION_CODE=$(echo ${CUDA_VERSION} | sed -e "s/\.//" -e "s/\(...\).*/\1/") + echo "Using CUDA_VERSION ${CUDA_VERSION}" + if [[ "${CUDA_VERSION_CODE}" != "111" ]] && [[ "${CUDA_VERSION_CODE}" != "102" ]] ; then + echo "CUDA version must be either 11.1 or 10.2" + exit 1 + fi + echo "export CUDA_HOME=${CUDA_HOME}" >> ${venv_dir}/bin/activate +fi + +CONSTRAINTS_FILE=$(tempfile) +cat constraints.txt >> ${CONSTRAINTS_FILE} +export PIP_CONSTRAINT=${CONSTRAINTS_FILE} + +# Newer versions of pip have troubles with NNCF installation from the repo commit. +pip install pip==21.2.1 || exit 1 +pip install wheel || exit 1 +pip install --upgrade setuptools || exit 1 + +if [[ -z $CUDA_VERSION_CODE ]]; then + export TORCH_VERSION=${TORCH_VERSION}+cpu + export TORCHVISION_VERSION=${TORCHVISION_VERSION}+cpu +else + export TORCH_VERSION=${TORCH_VERSION}+cu${CUDA_VERSION_CODE} + export TORCHVISION_VERSION=${TORCHVISION_VERSION}+cu${CUDA_VERSION_CODE} +fi + +pip install torch==${TORCH_VERSION} torchvision==${TORCHVISION_VERSION} -f https://download.pytorch.org/whl/lts/1.8/torch_lts.html --no-cache || exit 1 +echo torch==${TORCH_VERSION} >> ${CONSTRAINTS_FILE} +echo torchvision==${TORCHVISION_VERSION} >> ${CONSTRAINTS_FILE} + +pip install --no-cache-dir mmcv-full==${MMCV_VERSION} || exit 1 + +# Install other requirements. +# Install mmpycocotools from source to make sure it is compatible with installed numpy version. +pip install --no-cache-dir --no-binary=mmpycocotools mmpycocotools || exit 1 +cd submodule +cat requirements.txt | xargs -n 1 -L 1 pip install --no-cache || exit 1 +# Install algo backend. +pip install -e . || exit 1 +cd .. + +# Install OTE SDK +pip install -e ../../ote_sdk/ || exit 1 + +# Install tasks. +pip install -e . + +# Build NNCF extensions +echo "Build NNCF extensions ..." +python -c "import nncf" + +deactivate + +echo +echo "Activate a virtual environment to start working:" +echo "$ . ${venv_dir}/bin/activate" diff --git a/external/mmdetection/ote_tests_pytest.ini b/external/mmdetection/ote_tests_pytest.ini new file mode 100644 index 00000000000..440f43f8b26 --- /dev/null +++ b/external/mmdetection/ote_tests_pytest.ini @@ -0,0 +1,2 @@ +[pytest] +python_files = test_ote_*.py diff --git a/external/mmdetection/requirements.txt b/external/mmdetection/requirements.txt new file mode 100644 index 00000000000..7feb6338638 --- /dev/null +++ b/external/mmdetection/requirements.txt @@ -0,0 +1,5 @@ + +openvino==2022.1.0.dev20220302 +openvino-dev==2022.1.0.dev20220302 +openmodelzoo-modelapi @ git+https://github.com/openvinotoolkit/open_model_zoo@ef556fee2cdd92488838b49ef8939c303992d89c#egg=openmodelzoo-modelapi&subdirectory=demos/common/python +nncf@ git+https://github.com/openvinotoolkit/nncf@464244204fc2c5e80c8164c17d8d266ccae50062#egg=nncf diff --git a/external/mmdetection/setup.py b/external/mmdetection/setup.py new file mode 100644 index 00000000000..0c080f00908 --- /dev/null +++ b/external/mmdetection/setup.py @@ -0,0 +1,23 @@ +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +import os.path as osp +from setuptools import setup, find_packages + +repo_root = osp.dirname(osp.realpath(__file__)) + +def get_requirements(filename): + requires = [] + with open(osp.join(repo_root, filename), 'r') as f: + for line in f.readlines(): + requires.append(line.strip()) + return requires + +requirements = get_requirements('requirements.txt') + +setup( + name='detection_tasks', + packages=find_packages(), + install_requires=requirements, +) diff --git a/external/mmdetection/submodule b/external/mmdetection/submodule new file mode 160000 index 00000000000..0445e26bc64 --- /dev/null +++ b/external/mmdetection/submodule @@ -0,0 +1 @@ +Subproject commit 0445e26bc64f7bbef9161860370300f376135f12 diff --git a/external/mmdetection/tests/conftest.py b/external/mmdetection/tests/conftest.py new file mode 100644 index 00000000000..c1d3d1a705c --- /dev/null +++ b/external/mmdetection/tests/conftest.py @@ -0,0 +1,62 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + + +import pytest + +from ote_sdk.test_suite.pytest_insertions import * +from ote_sdk.test_suite.training_tests_common import REALLIFE_USECASE_CONSTANT + +pytest_plugins = get_pytest_plugins_from_ote() + +ote_conftest_insertion(default_repository_name='ote/training_extensions/external/mmdetection') + +@pytest.fixture +def ote_test_domain_fx(): + return 'custom-object-detection' + +@pytest.fixture +def ote_test_scenario_fx(current_test_parameters_fx): + assert isinstance(current_test_parameters_fx, dict) + if current_test_parameters_fx.get('usecase') == REALLIFE_USECASE_CONSTANT: + return 'performance' + else: + return 'integration' + +@pytest.fixture(scope='session') +def ote_templates_root_dir_fx(): + import os.path as osp + import logging + logger = logging.getLogger(__name__) + root = osp.dirname(osp.dirname(osp.realpath(__file__))) + root = f'{root}/configs/' + logger.debug(f'overloaded ote_templates_root_dir_fx: return {root}') + return root + +@pytest.fixture(scope='session') +def ote_reference_root_dir_fx(): + import os.path as osp + import logging + logger = logging.getLogger(__name__) + root = osp.dirname(osp.dirname(osp.realpath(__file__))) + root = f'{root}/tests/reference/' + logger.debug(f'overloaded ote_reference_root_dir_fx: return {root}') + return root + +# pytest magic +def pytest_generate_tests(metafunc): + ote_pytest_generate_tests_insertion(metafunc) + +def pytest_addoption(parser): + ote_pytest_addoption_insertion(parser) diff --git a/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml b/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml new file mode 100644 index 00000000000..b27d326576b --- /dev/null +++ b/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml @@ -0,0 +1,351 @@ +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.81 + "max_diff_if_less_threshold": 0.005 + "max_diff_if_greater_threshold": 0.06 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.01 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.78 + "max_diff_if_less_threshold": 0.005 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.01 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-bbcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.017 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.82 + "max_diff_if_less_threshold": 0.005 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.01 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.69 + "max_diff_if_less_threshold": 0.005 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.01 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-weed-coco,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.944 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.924 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-pcd,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.561 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.661 + "max_diff_if_less_threshold": 0.06 + "max_diff_if_greater_threshold": 0.06 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.06 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-aerial,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.779 + "max_diff_if_less_threshold": 0.11 + "max_diff_if_greater_threshold": 0.11 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.11 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.11 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.11 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.11 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.925 + "max_diff_if_less_threshold": 0.05 + "max_diff_if_greater_threshold": 0.05 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.05 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.05 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.05 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-dice,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.05 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.884 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.884 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-fish,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.851 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.798 + "max_diff_if_less_threshold": 0.03 + "max_diff_if_greater_threshold": 0.03 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.03 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-vitens,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.835 + "max_diff_if_less_threshold": 0.06 + "max_diff_if_greater_threshold": 0.06 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.06 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_ATSS,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 + +? "ACTION-training_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.822 + "max_diff_if_less_threshold": 0.06 + "max_diff_if_greater_threshold": 0.06 +? "ACTION-export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 +? "ACTION-pot_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 +? "ACTION-nncf_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.06 +? "ACTION-nncf_export_evaluation,model-Custom_Object_Detection_Gen3_SSD,dataset-diopsis,num_iters-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.06 diff --git a/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_ATSS/nncf/nncf_quantization.dot b/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_ATSS/nncf/nncf_quantization.dot new file mode 100644 index 00000000000..6e9994009ac --- /dev/null +++ b/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_ATSS/nncf/nncf_quantization.dot @@ -0,0 +1,1179 @@ +strict digraph { +"0 /nncf_model_input_0" [id=0, type=nncf_model_input]; +"1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; +"2 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; +"3 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0" [id=3, type=conv2d]; +"4 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFBatchNorm[bn]/batch_norm_0" [id=4, type=batch_norm]; +"5 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/hardtanh_0" [id=5, type=hardtanh]; +"6 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; +"7 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=8, type=conv2d]; +"9 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=9, type=batch_norm]; +"10 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=10, type=hardtanh]; +"11 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=13, type=conv2d]; +"14 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=14, type=batch_norm]; +"15 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=15, type=hardtanh]; +"16 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=16, type=symmetric_quantize]; +"17 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=17, type=symmetric_quantize]; +"18 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=18, type=conv2d]; +"19 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=19, type=batch_norm]; +"20 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; +"22 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=22, type=conv2d]; +"23 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=23, type=batch_norm]; +"24 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=24, type=hardtanh]; +"25 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=27, type=conv2d]; +"28 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=28, type=batch_norm]; +"29 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=29, type=hardtanh]; +"30 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=31, type=symmetric_quantize]; +"32 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=32, type=conv2d]; +"33 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=33, type=batch_norm]; +"34 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=35, type=symmetric_quantize]; +"36 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=36, type=conv2d]; +"37 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=37, type=batch_norm]; +"38 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=38, type=hardtanh]; +"39 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=40, type=symmetric_quantize]; +"41 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=41, type=conv2d]; +"42 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=42, type=batch_norm]; +"43 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=43, type=hardtanh]; +"44 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; +"45 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=45, type=symmetric_quantize]; +"46 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=46, type=conv2d]; +"47 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=47, type=batch_norm]; +"48 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0" [id=49, type=__add__]; +"50 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; +"51 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=52, type=conv2d]; +"53 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=53, type=batch_norm]; +"54 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=54, type=hardtanh]; +"55 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; +"56 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=57, type=conv2d]; +"58 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=58, type=batch_norm]; +"59 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=59, type=hardtanh]; +"60 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=62, type=conv2d]; +"63 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=63, type=batch_norm]; +"64 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; +"65 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; +"66 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=66, type=conv2d]; +"67 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=67, type=batch_norm]; +"68 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=68, type=hardtanh]; +"69 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; +"70 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=71, type=conv2d]; +"72 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=72, type=batch_norm]; +"73 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=73, type=hardtanh]; +"74 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; +"75 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=75, type=symmetric_quantize]; +"76 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=76, type=conv2d]; +"77 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=77, type=batch_norm]; +"78 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=78, type=symmetric_quantize]; +"79 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0" [id=79, type=__add__]; +"80 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; +"82 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=82, type=conv2d]; +"83 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=83, type=batch_norm]; +"84 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=84, type=hardtanh]; +"85 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; +"86 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=87, type=conv2d]; +"88 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=88, type=batch_norm]; +"89 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=89, type=hardtanh]; +"90 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=90, type=symmetric_quantize]; +"91 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=91, type=symmetric_quantize]; +"92 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=92, type=conv2d]; +"93 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=93, type=batch_norm]; +"94 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0" [id=95, type=__add__]; +"96 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; +"97 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=98, type=conv2d]; +"99 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=99, type=batch_norm]; +"100 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=100, type=hardtanh]; +"101 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=103, type=conv2d]; +"104 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=104, type=batch_norm]; +"105 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=105, type=hardtanh]; +"106 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=106, type=symmetric_quantize]; +"107 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=107, type=symmetric_quantize]; +"108 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=108, type=conv2d]; +"109 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=109, type=batch_norm]; +"110 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=112, type=conv2d]; +"113 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=113, type=batch_norm]; +"114 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=114, type=hardtanh]; +"115 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=115, type=symmetric_quantize]; +"116 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=117, type=conv2d]; +"118 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=118, type=batch_norm]; +"119 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=119, type=hardtanh]; +"120 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=121, type=symmetric_quantize]; +"122 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=122, type=conv2d]; +"123 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=123, type=batch_norm]; +"124 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=124, type=symmetric_quantize]; +"125 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0" [id=125, type=__add__]; +"126 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; +"127 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=127, type=symmetric_quantize]; +"128 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=128, type=conv2d]; +"129 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=129, type=batch_norm]; +"130 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=130, type=hardtanh]; +"131 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; +"132 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=132, type=symmetric_quantize]; +"133 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=133, type=conv2d]; +"134 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=134, type=batch_norm]; +"135 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=135, type=hardtanh]; +"136 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=136, type=symmetric_quantize]; +"137 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=137, type=symmetric_quantize]; +"138 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=138, type=conv2d]; +"139 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=139, type=batch_norm]; +"140 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0" [id=141, type=__add__]; +"142 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; +"143 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=143, type=symmetric_quantize]; +"144 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=144, type=conv2d]; +"145 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=145, type=batch_norm]; +"146 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=146, type=hardtanh]; +"147 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; +"149 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=149, type=conv2d]; +"150 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=150, type=batch_norm]; +"151 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=151, type=hardtanh]; +"152 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=152, type=symmetric_quantize]; +"153 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=153, type=symmetric_quantize]; +"154 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=154, type=conv2d]; +"155 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=155, type=batch_norm]; +"156 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0" [id=157, type=__add__]; +"158 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/SymmetricQuantizer/symmetric_quantize_0" [id=158, type=symmetric_quantize]; +"159 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=159, type=symmetric_quantize]; +"160 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=160, type=conv2d]; +"161 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=161, type=batch_norm]; +"162 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=162, type=hardtanh]; +"163 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=163, type=symmetric_quantize]; +"164 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=164, type=symmetric_quantize]; +"165 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=165, type=conv2d]; +"166 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=166, type=batch_norm]; +"167 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=167, type=hardtanh]; +"168 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=168, type=symmetric_quantize]; +"169 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=169, type=symmetric_quantize]; +"170 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=170, type=conv2d]; +"171 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=171, type=batch_norm]; +"172 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=172, type=symmetric_quantize]; +"173 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=173, type=symmetric_quantize]; +"174 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=174, type=conv2d]; +"175 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=175, type=batch_norm]; +"176 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=176, type=hardtanh]; +"177 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; +"178 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=178, type=symmetric_quantize]; +"179 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=179, type=conv2d]; +"180 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=180, type=batch_norm]; +"181 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=181, type=hardtanh]; +"182 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=184, type=conv2d]; +"185 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=185, type=batch_norm]; +"186 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0" [id=187, type=__add__]; +"188 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; +"189 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=189, type=symmetric_quantize]; +"190 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=190, type=conv2d]; +"191 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=191, type=batch_norm]; +"192 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=192, type=hardtanh]; +"193 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; +"194 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=194, type=symmetric_quantize]; +"195 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=195, type=conv2d]; +"196 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=196, type=batch_norm]; +"197 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=197, type=hardtanh]; +"198 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; +"199 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=199, type=symmetric_quantize]; +"200 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=200, type=conv2d]; +"201 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=201, type=batch_norm]; +"202 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=202, type=symmetric_quantize]; +"203 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0" [id=203, type=__add__]; +"204 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" [id=204, type=symmetric_quantize]; +"205 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=205, type=symmetric_quantize]; +"206 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=206, type=conv2d]; +"207 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=207, type=batch_norm]; +"208 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=208, type=hardtanh]; +"209 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; +"210 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=210, type=symmetric_quantize]; +"211 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=211, type=conv2d]; +"212 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=212, type=batch_norm]; +"213 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=213, type=hardtanh]; +"214 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=214, type=symmetric_quantize]; +"215 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=215, type=symmetric_quantize]; +"216 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=216, type=conv2d]; +"217 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=217, type=batch_norm]; +"218 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=218, type=symmetric_quantize]; +"219 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=219, type=symmetric_quantize]; +"220 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=220, type=conv2d]; +"221 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=221, type=batch_norm]; +"222 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=222, type=hardtanh]; +"223 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; +"224 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; +"225 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=225, type=conv2d]; +"226 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=226, type=batch_norm]; +"227 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=227, type=hardtanh]; +"228 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=229, type=symmetric_quantize]; +"230 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=230, type=conv2d]; +"231 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=231, type=batch_norm]; +"232 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=232, type=symmetric_quantize]; +"233 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0" [id=233, type=__add__]; +"234 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=235, type=symmetric_quantize]; +"236 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=236, type=conv2d]; +"237 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=237, type=batch_norm]; +"238 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=238, type=hardtanh]; +"239 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; +"240 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=240, type=symmetric_quantize]; +"241 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=241, type=conv2d]; +"242 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=242, type=batch_norm]; +"243 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=243, type=hardtanh]; +"244 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; +"245 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=245, type=symmetric_quantize]; +"246 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=246, type=conv2d]; +"247 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=247, type=batch_norm]; +"248 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=248, type=symmetric_quantize]; +"249 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0" [id=249, type=__add__]; +"250 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=250, type=symmetric_quantize]; +"251 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=252, type=conv2d]; +"253 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=253, type=batch_norm]; +"254 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=254, type=hardtanh]; +"255 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=256, type=symmetric_quantize]; +"257 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=257, type=conv2d]; +"258 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=258, type=batch_norm]; +"259 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=259, type=hardtanh]; +"260 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=260, type=symmetric_quantize]; +"261 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=261, type=symmetric_quantize]; +"262 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=262, type=conv2d]; +"263 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=263, type=batch_norm]; +"264 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=264, type=symmetric_quantize]; +"265 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=265, type=symmetric_quantize]; +"266 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=266, type=conv2d]; +"267 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=267, type=symmetric_quantize]; +"268 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=268, type=symmetric_quantize]; +"269 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=269, type=conv2d]; +"270 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=270, type=symmetric_quantize]; +"271 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=271, type=symmetric_quantize]; +"272 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=272, type=conv2d]; +"273 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=273, type=symmetric_quantize]; +"274 ATSS/FPN[neck]/interpolate_0" [id=274, type=interpolate]; +"275 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; +"276 ATSS/FPN[neck]/__iadd___0" [id=276, type=__iadd__]; +"277 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" [id=277, type=symmetric_quantize]; +"278 ATSS/FPN[neck]/interpolate_1" [id=278, type=interpolate]; +"279 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" [id=279, type=symmetric_quantize]; +"280 ATSS/FPN[neck]/__iadd___1" [id=280, type=__iadd__]; +"281 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" [id=281, type=symmetric_quantize]; +"282 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=282, type=symmetric_quantize]; +"283 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=283, type=conv2d]; +"284 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=285, type=symmetric_quantize]; +"286 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=286, type=conv2d]; +"287 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=287, type=symmetric_quantize]; +"288 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=288, type=symmetric_quantize]; +"289 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=289, type=conv2d]; +"290 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=290, type=symmetric_quantize]; +"291 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=292, type=conv2d]; +"293 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=293, type=symmetric_quantize]; +"294 ATSS/FPN[neck]/relu_0" [id=294, type=relu]; +"295 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=295, type=symmetric_quantize]; +"296 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0" [id=296, type=conv2d]; +"297 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=297, type=symmetric_quantize]; +"298 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=298, type=symmetric_quantize]; +"299 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=299, type=conv2d]; +"300 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=300, type=symmetric_quantize]; +"301 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" [id=301, type=group_norm]; +"302 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__0" [id=302, type=relu_]; +"303 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=303, type=symmetric_quantize]; +"304 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=304, type=symmetric_quantize]; +"305 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=305, type=conv2d]; +"306 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=306, type=symmetric_quantize]; +"307 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" [id=307, type=group_norm]; +"308 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__0" [id=308, type=relu_]; +"309 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=309, type=symmetric_quantize]; +"310 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=310, type=symmetric_quantize]; +"311 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=311, type=conv2d]; +"312 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=312, type=symmetric_quantize]; +"313 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" [id=313, type=group_norm]; +"314 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__0" [id=314, type=relu_]; +"315 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=315, type=symmetric_quantize]; +"316 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=316, type=symmetric_quantize]; +"317 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=317, type=conv2d]; +"318 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=318, type=symmetric_quantize]; +"319 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_0" [id=319, type=group_norm]; +"320 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__0" [id=320, type=relu_]; +"321 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=321, type=symmetric_quantize]; +"322 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=322, type=symmetric_quantize]; +"323 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=323, type=conv2d]; +"324 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=324, type=symmetric_quantize]; +"325 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" [id=325, type=group_norm]; +"326 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__0" [id=326, type=relu_]; +"327 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=327, type=symmetric_quantize]; +"328 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=328, type=symmetric_quantize]; +"329 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=329, type=conv2d]; +"330 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=330, type=symmetric_quantize]; +"331 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" [id=331, type=group_norm]; +"332 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__0" [id=332, type=relu_]; +"333 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=333, type=symmetric_quantize]; +"334 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=334, type=symmetric_quantize]; +"335 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=335, type=conv2d]; +"336 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=336, type=symmetric_quantize]; +"337 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" [id=337, type=group_norm]; +"338 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0" [id=338, type=relu_]; +"339 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=340, type=symmetric_quantize]; +"341 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=341, type=conv2d]; +"342 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=342, type=symmetric_quantize]; +"343 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_0" [id=343, type=group_norm]; +"344 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__0" [id=344, type=relu_]; +"345 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=345, type=symmetric_quantize]; +"346 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=346, type=symmetric_quantize]; +"347 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_0" [id=347, type=conv2d]; +"348 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=348, type=symmetric_quantize]; +"349 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_0" [id=349, type=conv2d]; +"350 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_0" [id=350, type=symmetric_quantize]; +"351 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[0]/__mul___0" [id=351, type=__mul__]; +"352 ATSS/ATSSHead[bbox_head]/float_0" [id=352, type=float]; +"353 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=353, type=symmetric_quantize]; +"354 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_0" [id=354, type=conv2d]; +"355 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=355, type=symmetric_quantize]; +"356 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" [id=356, type=conv2d]; +"357 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=357, type=symmetric_quantize]; +"358 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" [id=358, type=group_norm]; +"359 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__1" [id=359, type=relu_]; +"360 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=360, type=symmetric_quantize]; +"361 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=361, type=symmetric_quantize]; +"362 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" [id=362, type=conv2d]; +"363 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=363, type=symmetric_quantize]; +"364 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" [id=364, type=group_norm]; +"365 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__1" [id=365, type=relu_]; +"366 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=366, type=symmetric_quantize]; +"367 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=367, type=symmetric_quantize]; +"368 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" [id=368, type=conv2d]; +"369 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=369, type=symmetric_quantize]; +"370 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" [id=370, type=group_norm]; +"371 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__1" [id=371, type=relu_]; +"372 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=372, type=symmetric_quantize]; +"373 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=373, type=symmetric_quantize]; +"374 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1" [id=374, type=conv2d]; +"375 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=375, type=symmetric_quantize]; +"376 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_1" [id=376, type=group_norm]; +"377 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__1" [id=377, type=relu_]; +"378 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=378, type=symmetric_quantize]; +"379 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=379, type=symmetric_quantize]; +"380 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" [id=380, type=conv2d]; +"381 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=381, type=symmetric_quantize]; +"382 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" [id=382, type=group_norm]; +"383 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__1" [id=383, type=relu_]; +"384 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=384, type=symmetric_quantize]; +"385 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=385, type=symmetric_quantize]; +"386 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" [id=386, type=conv2d]; +"387 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=387, type=symmetric_quantize]; +"388 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" [id=388, type=group_norm]; +"389 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__1" [id=389, type=relu_]; +"390 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=390, type=symmetric_quantize]; +"391 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=391, type=symmetric_quantize]; +"392 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" [id=392, type=conv2d]; +"393 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=393, type=symmetric_quantize]; +"394 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" [id=394, type=group_norm]; +"395 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1" [id=395, type=relu_]; +"396 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=396, type=symmetric_quantize]; +"397 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=397, type=symmetric_quantize]; +"398 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1" [id=398, type=conv2d]; +"399 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=399, type=symmetric_quantize]; +"400 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_1" [id=400, type=group_norm]; +"401 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__1" [id=401, type=relu_]; +"402 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=402, type=symmetric_quantize]; +"403 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=403, type=symmetric_quantize]; +"404 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_1" [id=404, type=conv2d]; +"405 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=405, type=symmetric_quantize]; +"406 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_1" [id=406, type=conv2d]; +"407 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_1" [id=407, type=symmetric_quantize]; +"408 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[1]/__mul___0" [id=408, type=__mul__]; +"409 ATSS/ATSSHead[bbox_head]/float_1" [id=409, type=float]; +"410 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=410, type=symmetric_quantize]; +"411 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_1" [id=411, type=conv2d]; +"412 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=412, type=symmetric_quantize]; +"413 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" [id=413, type=conv2d]; +"414 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=414, type=symmetric_quantize]; +"415 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" [id=415, type=group_norm]; +"416 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__2" [id=416, type=relu_]; +"417 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=417, type=symmetric_quantize]; +"418 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=418, type=symmetric_quantize]; +"419 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" [id=419, type=conv2d]; +"420 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=420, type=symmetric_quantize]; +"421 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" [id=421, type=group_norm]; +"422 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__2" [id=422, type=relu_]; +"423 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=423, type=symmetric_quantize]; +"424 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=424, type=symmetric_quantize]; +"425 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" [id=425, type=conv2d]; +"426 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=426, type=symmetric_quantize]; +"427 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" [id=427, type=group_norm]; +"428 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__2" [id=428, type=relu_]; +"429 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=429, type=symmetric_quantize]; +"430 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=430, type=symmetric_quantize]; +"431 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2" [id=431, type=conv2d]; +"432 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=432, type=symmetric_quantize]; +"433 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_2" [id=433, type=group_norm]; +"434 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__2" [id=434, type=relu_]; +"435 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=435, type=symmetric_quantize]; +"436 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=436, type=symmetric_quantize]; +"437 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" [id=437, type=conv2d]; +"438 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=438, type=symmetric_quantize]; +"439 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" [id=439, type=group_norm]; +"440 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__2" [id=440, type=relu_]; +"441 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=441, type=symmetric_quantize]; +"442 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=442, type=symmetric_quantize]; +"443 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" [id=443, type=conv2d]; +"444 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=444, type=symmetric_quantize]; +"445 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" [id=445, type=group_norm]; +"446 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__2" [id=446, type=relu_]; +"447 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=447, type=symmetric_quantize]; +"448 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=448, type=symmetric_quantize]; +"449 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" [id=449, type=conv2d]; +"450 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=450, type=symmetric_quantize]; +"451 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" [id=451, type=group_norm]; +"452 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2" [id=452, type=relu_]; +"453 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=453, type=symmetric_quantize]; +"454 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=454, type=symmetric_quantize]; +"455 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2" [id=455, type=conv2d]; +"456 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=456, type=symmetric_quantize]; +"457 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_2" [id=457, type=group_norm]; +"458 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__2" [id=458, type=relu_]; +"459 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=459, type=symmetric_quantize]; +"460 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=460, type=symmetric_quantize]; +"461 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_2" [id=461, type=conv2d]; +"462 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=462, type=symmetric_quantize]; +"463 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_2" [id=463, type=conv2d]; +"464 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_2" [id=464, type=symmetric_quantize]; +"465 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[2]/__mul___0" [id=465, type=__mul__]; +"466 ATSS/ATSSHead[bbox_head]/float_2" [id=466, type=float]; +"467 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=467, type=symmetric_quantize]; +"468 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_2" [id=468, type=conv2d]; +"469 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=469, type=symmetric_quantize]; +"470 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" [id=470, type=conv2d]; +"471 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=471, type=symmetric_quantize]; +"472 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" [id=472, type=group_norm]; +"473 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__3" [id=473, type=relu_]; +"474 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=474, type=symmetric_quantize]; +"475 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=475, type=symmetric_quantize]; +"476 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" [id=476, type=conv2d]; +"477 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=477, type=symmetric_quantize]; +"478 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" [id=478, type=group_norm]; +"479 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__3" [id=479, type=relu_]; +"480 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=480, type=symmetric_quantize]; +"481 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=481, type=symmetric_quantize]; +"482 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" [id=482, type=conv2d]; +"483 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=483, type=symmetric_quantize]; +"484 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" [id=484, type=group_norm]; +"485 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__3" [id=485, type=relu_]; +"486 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=486, type=symmetric_quantize]; +"487 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=487, type=symmetric_quantize]; +"488 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3" [id=488, type=conv2d]; +"489 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=489, type=symmetric_quantize]; +"490 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_3" [id=490, type=group_norm]; +"491 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__3" [id=491, type=relu_]; +"492 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=492, type=symmetric_quantize]; +"493 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=493, type=symmetric_quantize]; +"494 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" [id=494, type=conv2d]; +"495 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=495, type=symmetric_quantize]; +"496 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" [id=496, type=group_norm]; +"497 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__3" [id=497, type=relu_]; +"498 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=498, type=symmetric_quantize]; +"499 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=499, type=symmetric_quantize]; +"500 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" [id=500, type=conv2d]; +"501 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=501, type=symmetric_quantize]; +"502 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" [id=502, type=group_norm]; +"503 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__3" [id=503, type=relu_]; +"504 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=504, type=symmetric_quantize]; +"505 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=505, type=symmetric_quantize]; +"506 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" [id=506, type=conv2d]; +"507 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=507, type=symmetric_quantize]; +"508 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" [id=508, type=group_norm]; +"509 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3" [id=509, type=relu_]; +"510 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=510, type=symmetric_quantize]; +"511 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=511, type=symmetric_quantize]; +"512 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3" [id=512, type=conv2d]; +"513 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=513, type=symmetric_quantize]; +"514 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_3" [id=514, type=group_norm]; +"515 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__3" [id=515, type=relu_]; +"516 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=516, type=symmetric_quantize]; +"517 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=517, type=symmetric_quantize]; +"518 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_3" [id=518, type=conv2d]; +"519 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=519, type=symmetric_quantize]; +"520 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_3" [id=520, type=conv2d]; +"521 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_3" [id=521, type=symmetric_quantize]; +"522 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[3]/__mul___0" [id=522, type=__mul__]; +"523 ATSS/ATSSHead[bbox_head]/float_3" [id=523, type=float]; +"524 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=524, type=symmetric_quantize]; +"525 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_3" [id=525, type=conv2d]; +"526 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=526, type=symmetric_quantize]; +"527 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" [id=527, type=conv2d]; +"528 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=528, type=symmetric_quantize]; +"529 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" [id=529, type=group_norm]; +"530 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__4" [id=530, type=relu_]; +"531 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=531, type=symmetric_quantize]; +"532 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=532, type=symmetric_quantize]; +"533 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" [id=533, type=conv2d]; +"534 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=534, type=symmetric_quantize]; +"535 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" [id=535, type=group_norm]; +"536 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__4" [id=536, type=relu_]; +"537 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=537, type=symmetric_quantize]; +"538 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=538, type=symmetric_quantize]; +"539 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" [id=539, type=conv2d]; +"540 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=540, type=symmetric_quantize]; +"541 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" [id=541, type=group_norm]; +"542 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__4" [id=542, type=relu_]; +"543 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=543, type=symmetric_quantize]; +"544 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=544, type=symmetric_quantize]; +"545 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4" [id=545, type=conv2d]; +"546 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=546, type=symmetric_quantize]; +"547 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_4" [id=547, type=group_norm]; +"548 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__4" [id=548, type=relu_]; +"549 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=549, type=symmetric_quantize]; +"550 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=550, type=symmetric_quantize]; +"551 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" [id=551, type=conv2d]; +"552 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=552, type=symmetric_quantize]; +"553 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" [id=553, type=group_norm]; +"554 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__4" [id=554, type=relu_]; +"555 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=555, type=symmetric_quantize]; +"556 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=556, type=symmetric_quantize]; +"557 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" [id=557, type=conv2d]; +"558 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=558, type=symmetric_quantize]; +"559 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" [id=559, type=group_norm]; +"560 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__4" [id=560, type=relu_]; +"561 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=561, type=symmetric_quantize]; +"562 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=562, type=symmetric_quantize]; +"563 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" [id=563, type=conv2d]; +"564 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=564, type=symmetric_quantize]; +"565 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" [id=565, type=group_norm]; +"566 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4" [id=566, type=relu_]; +"567 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=567, type=symmetric_quantize]; +"568 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=568, type=symmetric_quantize]; +"569 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4" [id=569, type=conv2d]; +"570 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=570, type=symmetric_quantize]; +"571 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_4" [id=571, type=group_norm]; +"572 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__4" [id=572, type=relu_]; +"573 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=573, type=symmetric_quantize]; +"574 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=574, type=symmetric_quantize]; +"575 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_4" [id=575, type=conv2d]; +"576 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=576, type=symmetric_quantize]; +"577 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_4" [id=577, type=conv2d]; +"578 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_4" [id=578, type=symmetric_quantize]; +"579 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[4]/__mul___0" [id=579, type=__mul__]; +"580 ATSS/ATSSHead[bbox_head]/float_4" [id=580, type=float]; +"581 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=581, type=symmetric_quantize]; +"582 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_4" [id=582, type=conv2d]; +"0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0"; +"2 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0"; +"3 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0" -> "4 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFBatchNorm[bn]/batch_norm_0"; +"4 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFBatchNorm[bn]/batch_norm_0" -> "5 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/hardtanh_0"; +"5 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/hardtanh_0" -> "6 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"6 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "8 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"7 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"8 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "9 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"9 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "10 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"10 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "11 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"11 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "13 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"12 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "13 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"13 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "14 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"14 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "15 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"15 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "16 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"16 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "18 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"17 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "18 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"18 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "19 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"19 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "20 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"20 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "22 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"21 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"22 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "23 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"23 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "24 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"24 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "25 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"25 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "27 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"26 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "27 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"27 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "28 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"28 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "29 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"29 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "30 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"30 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "32 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"31 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "32 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"32 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "33 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"33 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "34 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"34 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "36 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"34 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "49 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0"; +"35 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "36 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"36 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "37 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"37 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "38 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"38 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "39 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"39 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "41 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"40 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "41 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"41 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "42 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"42 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "43 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"43 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "44 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"44 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "46 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"45 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "46 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"46 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "47 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"47 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "48 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"48 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "49 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0"; +"49 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0" -> "50 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"50 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "52 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"51 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"52 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "53 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"53 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "54 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"54 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "55 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"55 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "57 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"56 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"57 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "58 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"58 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "59 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"59 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "60 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"60 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "62 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"61 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"62 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "63 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"63 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "64 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"64 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "66 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"64 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "79 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0"; +"65 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"66 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "67 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"67 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "68 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"68 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "69 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"69 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "71 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"70 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "71 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"71 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "72 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"72 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "73 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"73 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "74 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"74 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "76 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"75 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "76 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"76 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "77 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"77 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "78 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"78 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "79 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0"; +"79 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0" -> "80 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"80 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "82 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"80 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "95 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0"; +"81 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"82 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "83 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"83 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "84 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"84 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "85 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"85 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "87 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"86 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "87 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"87 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "88 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"88 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "89 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"89 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "90 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"90 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "92 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"91 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "92 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"92 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "93 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"93 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "94 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"94 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "95 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0"; +"95 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0" -> "96 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"96 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "98 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"96 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "266 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"97 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "98 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"98 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "99 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"99 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "100 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"100 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "101 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"101 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "103 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"102 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "103 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"103 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "104 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"104 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "105 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"105 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "106 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"106 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "108 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"107 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "108 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"108 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "109 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"109 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "110 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"110 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "112 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"110 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "125 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0"; +"111 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"112 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "113 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"113 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "114 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"114 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "115 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"115 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "117 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"116 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "117 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"117 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "118 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"118 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "119 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"119 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "120 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"120 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "122 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"121 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "122 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"122 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "123 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"123 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "124 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"124 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "125 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0"; +"125 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0" -> "126 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"126 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "128 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"126 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "141 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0"; +"127 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "128 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"128 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "129 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"129 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "130 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"130 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "131 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"131 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "133 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"132 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "133 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"133 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "134 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"134 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "135 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"135 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "136 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"136 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "138 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"137 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "138 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"138 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "139 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"139 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "140 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"140 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "141 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0"; +"141 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0" -> "142 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"142 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "144 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"142 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "157 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0"; +"143 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "144 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"144 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "145 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"145 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "146 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"146 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "147 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"147 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "149 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"148 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"149 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "150 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"150 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "151 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"151 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "152 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"152 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "154 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"153 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "154 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"154 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "155 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"155 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "156 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"156 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "157 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0"; +"157 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0" -> "158 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/SymmetricQuantizer/symmetric_quantize_0"; +"158 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/SymmetricQuantizer/symmetric_quantize_0" -> "160 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"159 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "160 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"160 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "161 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"161 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "162 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"162 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "163 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"163 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "165 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"164 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "165 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"165 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "166 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"166 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "167 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"167 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "168 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"168 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "170 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"169 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "170 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"170 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "171 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"171 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "172 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"172 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "174 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"172 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "187 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0"; +"173 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "174 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"174 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "175 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"175 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "176 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"176 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "177 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"177 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "179 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"178 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "179 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"179 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "180 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"180 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "181 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"181 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "182 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"182 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "184 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"183 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "184 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"184 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "185 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"185 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "186 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"186 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "187 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0"; +"187 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0" -> "188 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0"; +"188 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0" -> "190 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"188 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0" -> "203 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0"; +"189 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "190 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"190 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "191 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"191 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "192 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"192 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "193 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"193 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "195 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"194 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "195 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"195 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "196 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"196 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "197 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"197 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "198 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"198 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "200 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"199 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "200 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"200 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "201 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"201 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "202 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"202 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "203 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0"; +"203 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0" -> "204 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0"; +"204 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "206 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"204 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "269 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"205 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "206 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"206 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "207 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"207 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "208 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"208 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "209 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"209 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "211 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"210 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "211 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"211 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "212 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"212 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "213 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"213 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "214 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"214 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "216 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"215 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "216 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"216 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "217 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"217 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "218 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"218 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "220 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"218 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "233 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0"; +"219 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "220 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"220 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "221 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"221 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "222 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"222 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "223 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"223 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "225 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"224 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"225 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "226 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"226 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "227 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"227 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "228 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"228 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "230 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"229 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "230 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"230 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "231 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"231 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "232 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"232 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "233 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0"; +"233 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0" -> "234 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"234 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "236 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"234 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "249 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0"; +"235 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "236 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"236 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "237 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"237 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "238 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"238 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "239 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"239 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "241 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"240 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "241 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"241 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "242 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"242 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "243 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"243 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "244 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"244 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "246 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"245 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "246 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"246 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "247 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"247 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "248 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"248 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "249 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0"; +"249 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0" -> "250 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"250 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "252 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"251 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "252 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"252 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "253 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"253 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "254 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"254 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "255 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"255 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "257 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"256 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "257 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"257 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "258 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"258 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "259 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"259 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "260 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"260 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "262 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"261 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "262 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"262 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "263 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"263 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "264 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"264 ATSS/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "272 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"265 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "266 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"266 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "267 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"267 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "280 ATSS/FPN[neck]/__iadd___1"; +"268 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "269 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"269 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "270 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"270 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "276 ATSS/FPN[neck]/__iadd___0"; +"271 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "272 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"272 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "273 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"273 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "274 ATSS/FPN[neck]/interpolate_0"; +"273 ATSS/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "289 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"274 ATSS/FPN[neck]/interpolate_0" -> "275 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0"; +"275 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" -> "276 ATSS/FPN[neck]/__iadd___0"; +"276 ATSS/FPN[neck]/__iadd___0" -> "277 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1"; +"277 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "278 ATSS/FPN[neck]/interpolate_1"; +"277 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "286 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"278 ATSS/FPN[neck]/interpolate_1" -> "279 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2"; +"279 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" -> "280 ATSS/FPN[neck]/__iadd___1"; +"280 ATSS/FPN[neck]/__iadd___1" -> "281 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3"; +"281 ATSS/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" -> "283 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"282 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "283 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"283 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "284 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"284 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "299 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"284 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "323 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"285 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "286 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"286 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "287 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"287 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "356 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"287 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "380 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"288 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "289 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"289 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "290 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"290 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "292 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"290 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "413 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"290 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "437 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"291 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "292 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"292 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "293 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"293 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "294 ATSS/FPN[neck]/relu_0"; +"293 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "470 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"293 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "494 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"294 ATSS/FPN[neck]/relu_0" -> "296 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0"; +"295 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "296 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0"; +"296 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0" -> "297 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"297 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "527 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"297 ATSS/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "551 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"298 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "299 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"299 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "300 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"300 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "301 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0"; +"301 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" -> "302 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__0"; +"302 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__0" -> "303 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"303 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "305 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"304 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "305 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"305 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "306 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"306 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "307 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0"; +"307 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" -> "308 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__0"; +"308 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__0" -> "309 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"309 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "311 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"310 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "311 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"311 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "312 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"312 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "313 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0"; +"313 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" -> "314 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__0"; +"314 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "315 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"315 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "317 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"316 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "317 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"317 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "318 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"318 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "319 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_0"; +"319 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_0" -> "320 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__0"; +"320 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__0" -> "321 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"321 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "347 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_0"; +"322 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "323 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"323 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "324 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"324 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "325 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0"; +"325 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" -> "326 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__0"; +"326 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__0" -> "327 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"327 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "329 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"328 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "329 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"329 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "330 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"330 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "331 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0"; +"331 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" -> "332 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__0"; +"332 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__0" -> "333 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"333 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "335 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"334 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "335 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"335 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "336 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"336 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "337 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0"; +"337 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" -> "338 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0"; +"338 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "339 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"339 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "341 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"340 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "341 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"341 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "342 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"342 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "343 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_0"; +"343 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_0" -> "344 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__0"; +"344 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__0" -> "345 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"345 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "349 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_0"; +"345 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "354 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_0"; +"346 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "347 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_0"; +"348 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "349 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_0"; +"349 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_0" -> "350 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_0"; +"350 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_0" -> "351 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[0]/__mul___0"; +"351 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[0]/__mul___0" -> "352 ATSS/ATSSHead[bbox_head]/float_0"; +"353 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "354 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_0"; +"355 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "356 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"356 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" -> "357 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"357 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "358 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1"; +"358 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" -> "359 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__1"; +"359 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__1" -> "360 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"360 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "362 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"361 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "362 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"362 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" -> "363 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"363 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "364 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1"; +"364 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" -> "365 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__1"; +"365 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__1" -> "366 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"366 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "368 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"367 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "368 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"368 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" -> "369 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"369 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "370 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1"; +"370 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" -> "371 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__1"; +"371 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__1" -> "372 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"372 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "374 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1"; +"373 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "374 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1"; +"374 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1" -> "375 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"375 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "376 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_1"; +"376 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_1" -> "377 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__1"; +"377 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__1" -> "378 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"378 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "404 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_1"; +"379 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "380 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"380 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" -> "381 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"381 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "382 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1"; +"382 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" -> "383 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__1"; +"383 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__1" -> "384 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"384 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "386 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"385 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "386 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"386 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" -> "387 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"387 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "388 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1"; +"388 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" -> "389 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__1"; +"389 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__1" -> "390 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"390 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "392 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"391 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "392 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"392 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" -> "393 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"393 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "394 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1"; +"394 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" -> "395 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1"; +"395 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1" -> "396 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"396 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "398 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1"; +"397 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "398 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1"; +"398 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_1" -> "399 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"399 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "400 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_1"; +"400 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_1" -> "401 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__1"; +"401 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__1" -> "402 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"402 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "406 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_1"; +"402 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "411 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_1"; +"403 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "404 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_1"; +"405 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "406 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_1"; +"406 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_1" -> "407 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_1"; +"407 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_1" -> "408 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[1]/__mul___0"; +"408 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[1]/__mul___0" -> "409 ATSS/ATSSHead[bbox_head]/float_1"; +"410 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "411 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_1"; +"412 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "413 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"413 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" -> "414 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"414 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "415 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2"; +"415 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" -> "416 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__2"; +"416 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__2" -> "417 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"417 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "419 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"418 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "419 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"419 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" -> "420 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"420 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "421 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2"; +"421 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" -> "422 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__2"; +"422 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__2" -> "423 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"423 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "425 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"424 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "425 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"425 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" -> "426 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"426 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "427 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2"; +"427 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" -> "428 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__2"; +"428 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__2" -> "429 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"429 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "431 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2"; +"430 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "431 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2"; +"431 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2" -> "432 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"432 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "433 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_2"; +"433 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_2" -> "434 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__2"; +"434 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__2" -> "435 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"435 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "461 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_2"; +"436 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "437 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"437 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" -> "438 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"438 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "439 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2"; +"439 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" -> "440 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__2"; +"440 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__2" -> "441 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"441 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "443 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"442 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "443 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"443 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" -> "444 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"444 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "445 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2"; +"445 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" -> "446 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__2"; +"446 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__2" -> "447 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"447 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "449 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"448 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "449 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"449 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" -> "450 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"450 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "451 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2"; +"451 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" -> "452 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2"; +"452 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2" -> "453 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"453 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "455 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2"; +"454 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "455 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2"; +"455 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_2" -> "456 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"456 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "457 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_2"; +"457 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_2" -> "458 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__2"; +"458 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__2" -> "459 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"459 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "463 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_2"; +"459 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "468 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_2"; +"460 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "461 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_2"; +"462 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "463 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_2"; +"463 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_2" -> "464 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_2"; +"464 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_2" -> "465 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[2]/__mul___0"; +"465 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[2]/__mul___0" -> "466 ATSS/ATSSHead[bbox_head]/float_2"; +"467 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "468 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_2"; +"469 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "470 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"470 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" -> "471 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"471 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "472 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3"; +"472 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" -> "473 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__3"; +"473 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__3" -> "474 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"474 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "476 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"475 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "476 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"476 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" -> "477 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"477 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "478 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3"; +"478 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" -> "479 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__3"; +"479 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__3" -> "480 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"480 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "482 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"481 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "482 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"482 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" -> "483 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"483 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "484 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3"; +"484 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" -> "485 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__3"; +"485 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__3" -> "486 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"486 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "488 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3"; +"487 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "488 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3"; +"488 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3" -> "489 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"489 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "490 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_3"; +"490 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_3" -> "491 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__3"; +"491 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__3" -> "492 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"492 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "518 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_3"; +"493 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "494 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"494 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" -> "495 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"495 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "496 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3"; +"496 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" -> "497 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__3"; +"497 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__3" -> "498 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"498 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "500 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"499 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "500 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"500 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" -> "501 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"501 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "502 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3"; +"502 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" -> "503 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__3"; +"503 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__3" -> "504 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"504 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "506 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"505 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "506 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"506 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" -> "507 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"507 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "508 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3"; +"508 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" -> "509 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3"; +"509 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3" -> "510 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"510 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "512 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3"; +"511 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "512 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3"; +"512 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_3" -> "513 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"513 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "514 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_3"; +"514 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_3" -> "515 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__3"; +"515 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__3" -> "516 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"516 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "520 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_3"; +"516 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "525 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_3"; +"517 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "518 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_3"; +"519 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "520 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_3"; +"520 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_3" -> "521 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_3"; +"521 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_3" -> "522 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[3]/__mul___0"; +"522 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[3]/__mul___0" -> "523 ATSS/ATSSHead[bbox_head]/float_3"; +"524 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "525 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_3"; +"526 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "527 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"527 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" -> "528 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"528 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "529 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4"; +"529 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" -> "530 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__4"; +"530 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__4" -> "531 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"531 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "533 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"532 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "533 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"533 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" -> "534 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"534 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "535 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4"; +"535 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" -> "536 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__4"; +"536 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__4" -> "537 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"537 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "539 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"538 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "539 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"539 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" -> "540 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"540 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "541 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4"; +"541 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" -> "542 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__4"; +"542 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__4" -> "543 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"543 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "545 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4"; +"544 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "545 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4"; +"545 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4" -> "546 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"546 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "547 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_4"; +"547 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_4" -> "548 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__4"; +"548 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/relu__4" -> "549 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"549 ATSS/ATSSHead[bbox_head]/ModuleList[cls_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "575 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_4"; +"550 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "551 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"551 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" -> "552 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"552 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "553 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4"; +"553 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" -> "554 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__4"; +"554 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__4" -> "555 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"555 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "557 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"556 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "557 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"557 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" -> "558 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"558 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "559 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4"; +"559 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" -> "560 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__4"; +"560 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__4" -> "561 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"561 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "563 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"562 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "563 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"563 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" -> "564 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"564 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "565 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4"; +"565 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" -> "566 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4"; +"566 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4" -> "567 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"567 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "569 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4"; +"568 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "569 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4"; +"569 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_4" -> "570 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"570 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "571 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_4"; +"571 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/NNCFGroupNorm[gn]/group_norm_4" -> "572 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__4"; +"572 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/relu__4" -> "573 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"573 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "577 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_4"; +"573 ATSS/ATSSHead[bbox_head]/ModuleList[reg_convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "582 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_4"; +"574 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "575 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_cls]/conv2d_4"; +"576 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "577 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_4"; +"577 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/conv2d_4" -> "578 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_4"; +"578 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_reg]/SymmetricQuantizer/symmetric_quantize_4" -> "579 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[4]/__mul___0"; +"579 ATSS/ATSSHead[bbox_head]/ModuleList[scales]/Scale[4]/__mul___0" -> "580 ATSS/ATSSHead[bbox_head]/float_4"; +"581 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "582 ATSS/ATSSHead[bbox_head]/NNCFConv2d[atss_centerness]/conv2d_4"; +} diff --git a/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_SSD/nncf/nncf_quantization.dot b/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_SSD/nncf/nncf_quantization.dot new file mode 100644 index 00000000000..ee26bf7fd26 --- /dev/null +++ b/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_SSD/nncf/nncf_quantization.dot @@ -0,0 +1,597 @@ +strict digraph { +"0 /nncf_model_input_0" [id=0, type=nncf_model_input]; +"1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; +"2 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; +"3 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0" [id=3, type=conv2d]; +"4 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFBatchNorm[bn]/batch_norm_0" [id=4, type=batch_norm]; +"5 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/hardtanh_0" [id=5, type=hardtanh]; +"6 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; +"7 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=8, type=conv2d]; +"9 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=9, type=batch_norm]; +"10 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=10, type=hardtanh]; +"11 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=13, type=conv2d]; +"14 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=14, type=batch_norm]; +"15 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=15, type=hardtanh]; +"16 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=16, type=symmetric_quantize]; +"17 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=17, type=symmetric_quantize]; +"18 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=18, type=conv2d]; +"19 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=19, type=batch_norm]; +"20 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; +"22 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=22, type=conv2d]; +"23 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=23, type=batch_norm]; +"24 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=24, type=hardtanh]; +"25 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=27, type=conv2d]; +"28 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=28, type=batch_norm]; +"29 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=29, type=hardtanh]; +"30 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=31, type=symmetric_quantize]; +"32 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=32, type=conv2d]; +"33 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=33, type=batch_norm]; +"34 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=35, type=symmetric_quantize]; +"36 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=36, type=conv2d]; +"37 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=37, type=batch_norm]; +"38 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=38, type=hardtanh]; +"39 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=40, type=symmetric_quantize]; +"41 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=41, type=conv2d]; +"42 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=42, type=batch_norm]; +"43 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=43, type=hardtanh]; +"44 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; +"45 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=45, type=symmetric_quantize]; +"46 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=46, type=conv2d]; +"47 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=47, type=batch_norm]; +"48 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0" [id=49, type=__add__]; +"50 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; +"51 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=52, type=conv2d]; +"53 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=53, type=batch_norm]; +"54 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=54, type=hardtanh]; +"55 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; +"56 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=57, type=conv2d]; +"58 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=58, type=batch_norm]; +"59 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=59, type=hardtanh]; +"60 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=62, type=conv2d]; +"63 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=63, type=batch_norm]; +"64 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; +"65 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; +"66 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=66, type=conv2d]; +"67 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=67, type=batch_norm]; +"68 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=68, type=hardtanh]; +"69 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; +"70 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=71, type=conv2d]; +"72 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=72, type=batch_norm]; +"73 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=73, type=hardtanh]; +"74 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; +"75 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=75, type=symmetric_quantize]; +"76 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=76, type=conv2d]; +"77 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=77, type=batch_norm]; +"78 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=78, type=symmetric_quantize]; +"79 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0" [id=79, type=__add__]; +"80 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; +"82 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=82, type=conv2d]; +"83 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=83, type=batch_norm]; +"84 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=84, type=hardtanh]; +"85 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; +"86 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=87, type=conv2d]; +"88 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=88, type=batch_norm]; +"89 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=89, type=hardtanh]; +"90 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=90, type=symmetric_quantize]; +"91 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=91, type=symmetric_quantize]; +"92 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=92, type=conv2d]; +"93 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=93, type=batch_norm]; +"94 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0" [id=95, type=__add__]; +"96 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; +"97 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=98, type=conv2d]; +"99 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=99, type=batch_norm]; +"100 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=100, type=hardtanh]; +"101 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=103, type=conv2d]; +"104 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=104, type=batch_norm]; +"105 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=105, type=hardtanh]; +"106 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=106, type=symmetric_quantize]; +"107 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=107, type=symmetric_quantize]; +"108 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=108, type=conv2d]; +"109 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=109, type=batch_norm]; +"110 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=112, type=conv2d]; +"113 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=113, type=batch_norm]; +"114 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=114, type=hardtanh]; +"115 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=115, type=symmetric_quantize]; +"116 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=117, type=conv2d]; +"118 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=118, type=batch_norm]; +"119 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=119, type=hardtanh]; +"120 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=121, type=symmetric_quantize]; +"122 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=122, type=conv2d]; +"123 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=123, type=batch_norm]; +"124 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=124, type=symmetric_quantize]; +"125 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0" [id=125, type=__add__]; +"126 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; +"127 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=127, type=symmetric_quantize]; +"128 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=128, type=conv2d]; +"129 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=129, type=batch_norm]; +"130 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=130, type=hardtanh]; +"131 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; +"132 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=132, type=symmetric_quantize]; +"133 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=133, type=conv2d]; +"134 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=134, type=batch_norm]; +"135 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=135, type=hardtanh]; +"136 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=136, type=symmetric_quantize]; +"137 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=137, type=symmetric_quantize]; +"138 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=138, type=conv2d]; +"139 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=139, type=batch_norm]; +"140 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0" [id=141, type=__add__]; +"142 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; +"143 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=143, type=symmetric_quantize]; +"144 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=144, type=conv2d]; +"145 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=145, type=batch_norm]; +"146 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=146, type=hardtanh]; +"147 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; +"149 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=149, type=conv2d]; +"150 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=150, type=batch_norm]; +"151 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=151, type=hardtanh]; +"152 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=152, type=symmetric_quantize]; +"153 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=153, type=symmetric_quantize]; +"154 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=154, type=conv2d]; +"155 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=155, type=batch_norm]; +"156 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0" [id=157, type=__add__]; +"158 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/SymmetricQuantizer/symmetric_quantize_0" [id=158, type=symmetric_quantize]; +"159 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=159, type=symmetric_quantize]; +"160 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=160, type=conv2d]; +"161 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=161, type=batch_norm]; +"162 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=162, type=hardtanh]; +"163 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=163, type=symmetric_quantize]; +"164 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=164, type=symmetric_quantize]; +"165 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=165, type=conv2d]; +"166 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=166, type=batch_norm]; +"167 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=167, type=hardtanh]; +"168 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=168, type=symmetric_quantize]; +"169 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=169, type=symmetric_quantize]; +"170 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=170, type=conv2d]; +"171 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=171, type=batch_norm]; +"172 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=172, type=symmetric_quantize]; +"173 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=173, type=symmetric_quantize]; +"174 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=174, type=conv2d]; +"175 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=175, type=batch_norm]; +"176 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=176, type=hardtanh]; +"177 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; +"178 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=178, type=symmetric_quantize]; +"179 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=179, type=conv2d]; +"180 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=180, type=batch_norm]; +"181 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=181, type=hardtanh]; +"182 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=184, type=conv2d]; +"185 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=185, type=batch_norm]; +"186 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0" [id=187, type=__add__]; +"188 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; +"189 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=189, type=symmetric_quantize]; +"190 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=190, type=conv2d]; +"191 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=191, type=batch_norm]; +"192 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=192, type=hardtanh]; +"193 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; +"194 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=194, type=symmetric_quantize]; +"195 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=195, type=conv2d]; +"196 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=196, type=batch_norm]; +"197 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=197, type=hardtanh]; +"198 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; +"199 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=199, type=symmetric_quantize]; +"200 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=200, type=conv2d]; +"201 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=201, type=batch_norm]; +"202 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=202, type=symmetric_quantize]; +"203 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0" [id=203, type=__add__]; +"204 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" [id=204, type=symmetric_quantize]; +"205 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=205, type=symmetric_quantize]; +"206 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=206, type=conv2d]; +"207 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=207, type=batch_norm]; +"208 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=208, type=hardtanh]; +"209 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; +"210 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=210, type=symmetric_quantize]; +"211 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=211, type=conv2d]; +"212 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=212, type=batch_norm]; +"213 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=213, type=hardtanh]; +"214 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=214, type=symmetric_quantize]; +"215 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=215, type=symmetric_quantize]; +"216 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=216, type=conv2d]; +"217 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=217, type=batch_norm]; +"218 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=218, type=symmetric_quantize]; +"219 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=219, type=symmetric_quantize]; +"220 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=220, type=conv2d]; +"221 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=221, type=batch_norm]; +"222 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=222, type=hardtanh]; +"223 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; +"224 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; +"225 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=225, type=conv2d]; +"226 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=226, type=batch_norm]; +"227 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=227, type=hardtanh]; +"228 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=229, type=symmetric_quantize]; +"230 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=230, type=conv2d]; +"231 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=231, type=batch_norm]; +"232 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=232, type=symmetric_quantize]; +"233 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0" [id=233, type=__add__]; +"234 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=235, type=symmetric_quantize]; +"236 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=236, type=conv2d]; +"237 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=237, type=batch_norm]; +"238 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=238, type=hardtanh]; +"239 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; +"240 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=240, type=symmetric_quantize]; +"241 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=241, type=conv2d]; +"242 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=242, type=batch_norm]; +"243 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=243, type=hardtanh]; +"244 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; +"245 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=245, type=symmetric_quantize]; +"246 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=246, type=conv2d]; +"247 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=247, type=batch_norm]; +"248 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=248, type=symmetric_quantize]; +"249 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0" [id=249, type=__add__]; +"250 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=250, type=symmetric_quantize]; +"251 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=252, type=conv2d]; +"253 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" [id=253, type=batch_norm]; +"254 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" [id=254, type=hardtanh]; +"255 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=256, type=symmetric_quantize]; +"257 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=257, type=conv2d]; +"258 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" [id=258, type=batch_norm]; +"259 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" [id=259, type=hardtanh]; +"260 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=260, type=symmetric_quantize]; +"261 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=261, type=symmetric_quantize]; +"262 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=262, type=conv2d]; +"263 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" [id=263, type=batch_norm]; +"264 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=264, type=symmetric_quantize]; +"265 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=265, type=symmetric_quantize]; +"266 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0" [id=266, type=conv2d]; +"267 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFBatchNorm[1]/batch_norm_0" [id=267, type=batch_norm]; +"268 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/ReLU[2]/relu__0" [id=268, type=relu_]; +"269 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=269, type=symmetric_quantize]; +"270 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=270, type=symmetric_quantize]; +"271 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[3]/conv2d_0" [id=271, type=conv2d]; +"272 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=272, type=symmetric_quantize]; +"273 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0" [id=273, type=conv2d]; +"274 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFBatchNorm[1]/batch_norm_0" [id=274, type=batch_norm]; +"275 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/ReLU[2]/relu__0" [id=275, type=relu_]; +"276 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=276, type=symmetric_quantize]; +"277 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=277, type=symmetric_quantize]; +"278 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[3]/conv2d_0" [id=278, type=conv2d]; +"279 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=279, type=symmetric_quantize]; +"280 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0" [id=280, type=conv2d]; +"281 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFBatchNorm[1]/batch_norm_0" [id=281, type=batch_norm]; +"282 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/ReLU[2]/relu__0" [id=282, type=relu_]; +"283 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[3]/conv2d_0" [id=285, type=conv2d]; +"286 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=286, type=symmetric_quantize]; +"287 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0" [id=287, type=conv2d]; +"288 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFBatchNorm[1]/batch_norm_0" [id=288, type=batch_norm]; +"289 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/ReLU[2]/relu__0" [id=289, type=relu_]; +"290 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=290, type=symmetric_quantize]; +"291 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[3]/conv2d_0" [id=292, type=conv2d]; +"0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0"; +"2 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0"; +"3 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFConv2d[conv]/conv2d_0" -> "4 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFBatchNorm[bn]/batch_norm_0"; +"4 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/NNCFBatchNorm[bn]/batch_norm_0" -> "5 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/hardtanh_0"; +"5 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/hardtanh_0" -> "6 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"6 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/ConvBlock[init_block]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "8 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"7 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"8 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "9 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"9 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "10 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"10 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "11 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"11 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "13 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"12 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "13 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"13 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "14 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"14 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "15 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"15 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "16 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"16 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "18 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"17 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "18 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"18 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "19 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"19 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "20 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"20 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage1]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "22 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"21 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"22 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "23 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"23 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "24 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"24 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "25 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"25 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "27 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"26 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "27 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"27 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "28 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"28 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "29 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"29 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "30 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"30 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "32 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"31 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "32 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"32 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "33 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"33 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "34 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"34 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "36 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"34 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "49 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0"; +"35 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "36 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"36 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "37 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"37 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "38 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"38 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "39 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"39 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "41 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"40 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "41 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"41 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "42 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"42 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "43 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"43 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "44 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"44 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "46 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"45 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "46 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"46 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "47 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"47 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "48 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"48 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "49 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0"; +"49 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/__add___0" -> "50 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"50 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage2]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "52 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"51 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"52 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "53 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"53 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "54 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"54 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "55 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"55 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "57 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"56 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"57 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "58 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"58 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "59 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"59 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "60 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"60 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "62 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"61 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"62 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "63 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"63 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "64 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"64 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "66 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"64 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "79 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0"; +"65 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"66 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "67 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"67 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "68 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"68 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "69 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"69 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "71 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"70 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "71 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"71 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "72 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"72 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "73 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"73 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "74 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"74 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "76 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"75 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "76 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"76 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "77 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"77 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "78 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"78 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "79 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0"; +"79 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/__add___0" -> "80 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"80 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "82 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"80 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "95 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0"; +"81 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"82 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "83 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"83 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "84 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"84 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "85 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"85 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "87 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"86 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "87 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"87 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "88 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"88 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "89 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"89 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "90 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"90 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "92 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"91 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "92 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"92 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "93 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"93 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "94 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"94 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "95 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0"; +"95 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/__add___0" -> "96 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"96 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage3]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "98 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"97 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "98 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"98 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "99 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"99 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "100 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"100 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "101 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"101 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "103 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"102 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "103 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"103 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "104 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"104 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "105 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"105 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "106 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"106 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "108 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"107 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "108 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"108 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "109 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"109 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "110 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"110 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "112 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"110 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "125 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0"; +"111 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"112 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "113 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"113 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "114 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"114 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "115 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"115 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "117 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"116 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "117 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"117 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "118 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"118 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "119 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"119 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "120 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"120 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "122 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"121 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "122 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"122 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "123 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"123 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "124 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"124 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "125 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0"; +"125 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/__add___0" -> "126 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"126 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "128 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"126 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "141 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0"; +"127 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "128 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"128 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "129 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"129 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "130 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"130 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "131 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"131 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "133 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"132 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "133 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"133 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "134 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"134 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "135 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"135 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "136 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"136 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "138 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"137 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "138 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"138 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "139 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"139 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "140 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"140 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "141 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0"; +"141 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/__add___0" -> "142 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"142 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "144 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"142 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "157 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0"; +"143 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "144 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"144 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "145 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"145 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "146 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"146 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "147 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"147 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "149 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"148 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"149 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "150 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"150 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "151 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"151 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "152 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"152 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "154 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"153 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "154 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"154 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "155 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"155 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "156 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"156 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "157 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0"; +"157 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/__add___0" -> "158 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/SymmetricQuantizer/symmetric_quantize_0"; +"158 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit4]/SymmetricQuantizer/symmetric_quantize_0" -> "160 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"159 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "160 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"160 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "161 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"161 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "162 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"162 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "163 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"163 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "165 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"164 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "165 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"165 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "166 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"166 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "167 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"167 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "168 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"168 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "170 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"169 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "170 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"170 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "171 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"171 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "172 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"172 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "174 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"172 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit5]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "187 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0"; +"173 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "174 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"174 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "175 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"175 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "176 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"176 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "177 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"177 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "179 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"178 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "179 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"179 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "180 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"180 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "181 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"181 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "182 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"182 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "184 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"183 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "184 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"184 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "185 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"185 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "186 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"186 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "187 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0"; +"187 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/__add___0" -> "188 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0"; +"188 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0" -> "190 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"188 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit6]/SymmetricQuantizer/symmetric_quantize_0" -> "203 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0"; +"189 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "190 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"190 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "191 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"191 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "192 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"192 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "193 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"193 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "195 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"194 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "195 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"195 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "196 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"196 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "197 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"197 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "198 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"198 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "200 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"199 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "200 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"200 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "201 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"201 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "202 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"202 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "203 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0"; +"203 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/__add___0" -> "204 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0"; +"204 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "206 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"204 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "266 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; +"204 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage4]/LinearBottleneck[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "273 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; +"205 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "206 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"206 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "207 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"207 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "208 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"208 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "209 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"209 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "211 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"210 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "211 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"211 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "212 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"212 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "213 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"213 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "214 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"214 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "216 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"215 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "216 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"216 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "217 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"217 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "218 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"218 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "220 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"218 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit1]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "233 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0"; +"219 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "220 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"220 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "221 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"221 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "222 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"222 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "223 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"223 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "225 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"224 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"225 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "226 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"226 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "227 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"227 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "228 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"228 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "230 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"229 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "230 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"230 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "231 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"231 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "232 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"232 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "233 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0"; +"233 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/__add___0" -> "234 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"234 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "236 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"234 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "249 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0"; +"235 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "236 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"236 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "237 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"237 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "238 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"238 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "239 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"239 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "241 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"240 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "241 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"241 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "242 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"242 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "243 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"243 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "244 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"244 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "246 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"245 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "246 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"246 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "247 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"247 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "248 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"248 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "249 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0"; +"249 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/__add___0" -> "250 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"250 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "252 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"251 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "252 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"252 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "253 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0"; +"253 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/NNCFBatchNorm[bn]/batch_norm_0" -> "254 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0"; +"254 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/hardtanh_0" -> "255 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"255 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv1]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "257 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"256 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "257 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"257 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "258 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0"; +"258 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/NNCFBatchNorm[bn]/batch_norm_0" -> "259 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0"; +"259 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/hardtanh_0" -> "260 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"260 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv2]/ReLU6[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "262 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"261 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "262 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"262 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "263 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0"; +"263 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/batch_norm_0" -> "264 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"264 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "280 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; +"264 SingleStageDetector/mobilenetv2_w1[backbone]/Sequential[features]/Sequential[stage5]/LinearBottleneck[unit4]/ConvBlock[conv3]/NNCFBatchNorm[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "287 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; +"265 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "266 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; +"266 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0" -> "267 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFBatchNorm[1]/batch_norm_0"; +"267 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFBatchNorm[1]/batch_norm_0" -> "268 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/ReLU[2]/relu__0"; +"268 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/ReLU[2]/relu__0" -> "269 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"269 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "271 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[3]/conv2d_0"; +"270 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "271 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[0]/NNCFConv2d[3]/conv2d_0"; +"272 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "273 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; +"273 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[0]/conv2d_0" -> "274 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFBatchNorm[1]/batch_norm_0"; +"274 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFBatchNorm[1]/batch_norm_0" -> "275 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/ReLU[2]/relu__0"; +"275 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/ReLU[2]/relu__0" -> "276 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"276 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "278 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[3]/conv2d_0"; +"277 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "278 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[0]/NNCFConv2d[3]/conv2d_0"; +"279 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "280 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; +"280 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0" -> "281 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFBatchNorm[1]/batch_norm_0"; +"281 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFBatchNorm[1]/batch_norm_0" -> "282 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/ReLU[2]/relu__0"; +"282 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/ReLU[2]/relu__0" -> "283 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"283 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "285 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[3]/conv2d_0"; +"284 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "285 SingleStageDetector/SSDHead[bbox_head]/ModuleList[cls_convs]/Sequential[1]/NNCFConv2d[3]/conv2d_0"; +"286 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "287 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; +"287 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[0]/conv2d_0" -> "288 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFBatchNorm[1]/batch_norm_0"; +"288 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFBatchNorm[1]/batch_norm_0" -> "289 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/ReLU[2]/relu__0"; +"289 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/ReLU[2]/relu__0" -> "290 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"290 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "292 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[3]/conv2d_0"; +"291 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "292 SingleStageDetector/SSDHead[bbox_head]/ModuleList[reg_convs]/Sequential[1]/NNCFConv2d[3]/conv2d_0"; +} diff --git a/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_VFNet/nncf/nncf_quantization.dot b/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_VFNet/nncf/nncf_quantization.dot new file mode 100644 index 00000000000..f245897ecd8 --- /dev/null +++ b/external/mmdetection/tests/reference/Custom_Object_Detection_Gen3_VFNet/nncf/nncf_quantization.dot @@ -0,0 +1,1597 @@ +strict digraph { +"0 /nncf_model_input_0" [id=0, type=nncf_model_input]; +"1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; +"2 VFNet/ResNet[backbone]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; +"3 VFNet/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; +"4 VFNet/ResNet[backbone]/NNCFBatchNorm[bn1]/batch_norm_0" [id=4, type=batch_norm]; +"5 VFNet/ResNet[backbone]/ReLU[relu]/relu__0" [id=5, type=relu_]; +"6 VFNet/ResNet[backbone]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; +"7 VFNet/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0" [id=7, type=max_pool2d]; +"8 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=8, type=symmetric_quantize]; +"9 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=9, type=conv2d]; +"10 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" [id=10, type=batch_norm]; +"11 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__0" [id=11, type=relu_]; +"12 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=14, type=conv2d]; +"15 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" [id=15, type=batch_norm]; +"16 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__1" [id=16, type=relu_]; +"17 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=17, type=symmetric_quantize]; +"18 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=18, type=symmetric_quantize]; +"19 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=19, type=conv2d]; +"20 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" [id=20, type=batch_norm]; +"21 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=21, type=symmetric_quantize]; +"22 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=23, type=conv2d]; +"24 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" [id=24, type=batch_norm]; +"25 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0" [id=26, type=__iadd__]; +"27 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__2" [id=27, type=relu_]; +"28 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=28, type=symmetric_quantize]; +"29 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=29, type=symmetric_quantize]; +"30 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=30, type=conv2d]; +"31 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" [id=31, type=batch_norm]; +"32 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__0" [id=32, type=relu_]; +"33 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; +"34 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=35, type=conv2d]; +"36 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" [id=36, type=batch_norm]; +"37 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__1" [id=37, type=relu_]; +"38 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=38, type=symmetric_quantize]; +"39 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=40, type=conv2d]; +"41 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" [id=41, type=batch_norm]; +"42 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0" [id=43, type=__iadd__]; +"44 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__2" [id=44, type=relu_]; +"45 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=45, type=symmetric_quantize]; +"46 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=47, type=conv2d]; +"48 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" [id=48, type=batch_norm]; +"49 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__0" [id=49, type=relu_]; +"50 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; +"51 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=52, type=conv2d]; +"53 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" [id=53, type=batch_norm]; +"54 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__1" [id=54, type=relu_]; +"55 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=55, type=symmetric_quantize]; +"56 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=57, type=conv2d]; +"58 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" [id=58, type=batch_norm]; +"59 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=59, type=symmetric_quantize]; +"60 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0" [id=60, type=__iadd__]; +"61 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__2" [id=61, type=relu_]; +"62 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=62, type=symmetric_quantize]; +"63 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=63, type=symmetric_quantize]; +"64 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=64, type=conv2d]; +"65 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" [id=65, type=batch_norm]; +"66 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__0" [id=66, type=relu_]; +"67 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=67, type=symmetric_quantize]; +"68 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=68, type=symmetric_quantize]; +"69 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=69, type=conv2d]; +"70 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" [id=70, type=batch_norm]; +"71 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__1" [id=71, type=relu_]; +"72 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=72, type=symmetric_quantize]; +"73 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=73, type=symmetric_quantize]; +"74 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=74, type=conv2d]; +"75 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" [id=75, type=batch_norm]; +"76 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; +"77 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=77, type=symmetric_quantize]; +"78 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=78, type=conv2d]; +"79 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" [id=79, type=batch_norm]; +"80 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0" [id=81, type=__iadd__]; +"82 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__2" [id=82, type=relu_]; +"83 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=83, type=symmetric_quantize]; +"84 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=85, type=conv2d]; +"86 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" [id=86, type=batch_norm]; +"87 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__0" [id=87, type=relu_]; +"88 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; +"89 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=89, type=symmetric_quantize]; +"90 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=90, type=conv2d]; +"91 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" [id=91, type=batch_norm]; +"92 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__1" [id=92, type=relu_]; +"93 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=93, type=symmetric_quantize]; +"94 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=95, type=conv2d]; +"96 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" [id=96, type=batch_norm]; +"97 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0" [id=98, type=__iadd__]; +"99 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__2" [id=99, type=relu_]; +"100 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=100, type=symmetric_quantize]; +"101 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=102, type=conv2d]; +"103 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" [id=103, type=batch_norm]; +"104 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__0" [id=104, type=relu_]; +"105 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; +"106 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=106, type=symmetric_quantize]; +"107 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=107, type=conv2d]; +"108 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" [id=108, type=batch_norm]; +"109 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__1" [id=109, type=relu_]; +"110 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=110, type=symmetric_quantize]; +"111 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=112, type=conv2d]; +"113 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" [id=113, type=batch_norm]; +"114 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0" [id=115, type=__iadd__]; +"116 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__2" [id=116, type=relu_]; +"117 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=117, type=symmetric_quantize]; +"118 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=118, type=symmetric_quantize]; +"119 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=119, type=conv2d]; +"120 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn1]/batch_norm_0" [id=120, type=batch_norm]; +"121 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__0" [id=121, type=relu_]; +"122 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; +"123 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=124, type=conv2d]; +"125 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn2]/batch_norm_0" [id=125, type=batch_norm]; +"126 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__1" [id=126, type=relu_]; +"127 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=127, type=symmetric_quantize]; +"128 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=128, type=symmetric_quantize]; +"129 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" [id=129, type=conv2d]; +"130 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn3]/batch_norm_0" [id=130, type=batch_norm]; +"131 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; +"132 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0" [id=132, type=__iadd__]; +"133 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__2" [id=133, type=relu_]; +"134 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=134, type=symmetric_quantize]; +"135 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=135, type=symmetric_quantize]; +"136 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=136, type=conv2d]; +"137 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" [id=137, type=batch_norm]; +"138 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__0" [id=138, type=relu_]; +"139 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=141, type=conv2d]; +"142 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" [id=142, type=batch_norm]; +"143 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__1" [id=143, type=relu_]; +"144 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=144, type=symmetric_quantize]; +"145 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=146, type=conv2d]; +"147 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" [id=147, type=batch_norm]; +"148 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=148, type=symmetric_quantize]; +"149 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=150, type=conv2d]; +"151 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" [id=151, type=batch_norm]; +"152 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" [id=152, type=symmetric_quantize]; +"153 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0" [id=153, type=__iadd__]; +"154 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__2" [id=154, type=relu_]; +"155 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=155, type=symmetric_quantize]; +"156 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=157, type=conv2d]; +"158 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" [id=158, type=batch_norm]; +"159 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__0" [id=159, type=relu_]; +"160 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=160, type=symmetric_quantize]; +"161 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=162, type=conv2d]; +"163 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" [id=163, type=batch_norm]; +"164 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__1" [id=164, type=relu_]; +"165 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=165, type=symmetric_quantize]; +"166 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=166, type=symmetric_quantize]; +"167 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=167, type=conv2d]; +"168 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" [id=168, type=batch_norm]; +"169 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=169, type=symmetric_quantize]; +"170 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0" [id=170, type=__iadd__]; +"171 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__2" [id=171, type=relu_]; +"172 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=172, type=symmetric_quantize]; +"173 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=173, type=symmetric_quantize]; +"174 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=174, type=conv2d]; +"175 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" [id=175, type=batch_norm]; +"176 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__0" [id=176, type=relu_]; +"177 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; +"178 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=178, type=symmetric_quantize]; +"179 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=179, type=conv2d]; +"180 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" [id=180, type=batch_norm]; +"181 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__1" [id=181, type=relu_]; +"182 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=182, type=symmetric_quantize]; +"183 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=184, type=conv2d]; +"185 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" [id=185, type=batch_norm]; +"186 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0" [id=187, type=__iadd__]; +"188 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__2" [id=188, type=relu_]; +"189 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=189, type=symmetric_quantize]; +"190 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=190, type=symmetric_quantize]; +"191 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=191, type=conv2d]; +"192 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn1]/batch_norm_0" [id=192, type=batch_norm]; +"193 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__0" [id=193, type=relu_]; +"194 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=194, type=symmetric_quantize]; +"195 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=196, type=conv2d]; +"197 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn2]/batch_norm_0" [id=197, type=batch_norm]; +"198 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__1" [id=198, type=relu_]; +"199 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=199, type=symmetric_quantize]; +"200 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=200, type=symmetric_quantize]; +"201 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" [id=201, type=conv2d]; +"202 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn3]/batch_norm_0" [id=202, type=batch_norm]; +"203 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; +"204 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0" [id=204, type=__iadd__]; +"205 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__2" [id=205, type=relu_]; +"206 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=206, type=symmetric_quantize]; +"207 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=207, type=symmetric_quantize]; +"208 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=208, type=conv2d]; +"209 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn1]/batch_norm_0" [id=209, type=batch_norm]; +"210 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__0" [id=210, type=relu_]; +"211 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=211, type=symmetric_quantize]; +"212 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=212, type=symmetric_quantize]; +"213 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=213, type=conv2d]; +"214 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn2]/batch_norm_0" [id=214, type=batch_norm]; +"215 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__1" [id=215, type=relu_]; +"216 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=216, type=symmetric_quantize]; +"217 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=217, type=symmetric_quantize]; +"218 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0" [id=218, type=conv2d]; +"219 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn3]/batch_norm_0" [id=219, type=batch_norm]; +"220 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=220, type=symmetric_quantize]; +"221 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0" [id=221, type=__iadd__]; +"222 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__2" [id=222, type=relu_]; +"223 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=223, type=symmetric_quantize]; +"224 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; +"225 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=225, type=conv2d]; +"226 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn1]/batch_norm_0" [id=226, type=batch_norm]; +"227 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__0" [id=227, type=relu_]; +"228 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=229, type=symmetric_quantize]; +"230 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=230, type=conv2d]; +"231 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn2]/batch_norm_0" [id=231, type=batch_norm]; +"232 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__1" [id=232, type=relu_]; +"233 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=233, type=symmetric_quantize]; +"234 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0" [id=235, type=conv2d]; +"236 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn3]/batch_norm_0" [id=236, type=batch_norm]; +"237 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=237, type=symmetric_quantize]; +"238 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0" [id=238, type=__iadd__]; +"239 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__2" [id=239, type=relu_]; +"240 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=240, type=symmetric_quantize]; +"241 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=242, type=conv2d]; +"243 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" [id=243, type=batch_norm]; +"244 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__0" [id=244, type=relu_]; +"245 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=245, type=symmetric_quantize]; +"246 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=246, type=symmetric_quantize]; +"247 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=247, type=conv2d]; +"248 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" [id=248, type=batch_norm]; +"249 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__1" [id=249, type=relu_]; +"250 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=250, type=symmetric_quantize]; +"251 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=252, type=conv2d]; +"253 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" [id=253, type=batch_norm]; +"254 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=254, type=symmetric_quantize]; +"255 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=256, type=conv2d]; +"257 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" [id=257, type=batch_norm]; +"258 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" [id=258, type=symmetric_quantize]; +"259 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0" [id=259, type=__iadd__]; +"260 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__2" [id=260, type=relu_]; +"261 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=261, type=symmetric_quantize]; +"262 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=262, type=symmetric_quantize]; +"263 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=263, type=conv2d]; +"264 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" [id=264, type=batch_norm]; +"265 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__0" [id=265, type=relu_]; +"266 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=266, type=symmetric_quantize]; +"267 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=267, type=symmetric_quantize]; +"268 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=268, type=conv2d]; +"269 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" [id=269, type=batch_norm]; +"270 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__1" [id=270, type=relu_]; +"271 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=271, type=symmetric_quantize]; +"272 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=272, type=symmetric_quantize]; +"273 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=273, type=conv2d]; +"274 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" [id=274, type=batch_norm]; +"275 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; +"276 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0" [id=276, type=__iadd__]; +"277 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__2" [id=277, type=relu_]; +"278 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=278, type=symmetric_quantize]; +"279 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=279, type=symmetric_quantize]; +"280 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=280, type=conv2d]; +"281 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" [id=281, type=batch_norm]; +"282 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__0" [id=282, type=relu_]; +"283 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=285, type=conv2d]; +"286 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" [id=286, type=batch_norm]; +"287 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__1" [id=287, type=relu_]; +"288 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=288, type=symmetric_quantize]; +"289 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=290, type=conv2d]; +"291 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" [id=291, type=batch_norm]; +"292 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=292, type=symmetric_quantize]; +"293 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0" [id=293, type=__iadd__]; +"294 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__2" [id=294, type=relu_]; +"295 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=295, type=symmetric_quantize]; +"296 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=296, type=symmetric_quantize]; +"297 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=297, type=conv2d]; +"298 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=298, type=symmetric_quantize]; +"299 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=299, type=symmetric_quantize]; +"300 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=300, type=conv2d]; +"301 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=301, type=symmetric_quantize]; +"302 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=302, type=symmetric_quantize]; +"303 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=303, type=conv2d]; +"304 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=304, type=symmetric_quantize]; +"305 VFNet/FPN[neck]/interpolate_0" [id=305, type=interpolate]; +"306 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" [id=306, type=symmetric_quantize]; +"307 VFNet/FPN[neck]/__iadd___0" [id=307, type=__iadd__]; +"308 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" [id=308, type=symmetric_quantize]; +"309 VFNet/FPN[neck]/interpolate_1" [id=309, type=interpolate]; +"310 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" [id=310, type=symmetric_quantize]; +"311 VFNet/FPN[neck]/__iadd___1" [id=311, type=__iadd__]; +"312 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" [id=312, type=symmetric_quantize]; +"313 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=313, type=symmetric_quantize]; +"314 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=314, type=conv2d]; +"315 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=315, type=symmetric_quantize]; +"316 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=316, type=symmetric_quantize]; +"317 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=317, type=conv2d]; +"318 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=318, type=symmetric_quantize]; +"319 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=319, type=symmetric_quantize]; +"320 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=320, type=conv2d]; +"321 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=321, type=symmetric_quantize]; +"322 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=322, type=symmetric_quantize]; +"323 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=323, type=conv2d]; +"324 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=324, type=symmetric_quantize]; +"325 VFNet/FPN[neck]/relu_0" [id=325, type=relu]; +"326 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=326, type=symmetric_quantize]; +"327 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0" [id=327, type=conv2d]; +"328 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=328, type=symmetric_quantize]; +"329 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=329, type=symmetric_quantize]; +"330 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=330, type=conv2d]; +"331 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=331, type=symmetric_quantize]; +"332 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" [id=332, type=group_norm]; +"333 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__0" [id=333, type=relu_]; +"334 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=334, type=symmetric_quantize]; +"335 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=336, type=conv2d]; +"337 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" [id=338, type=group_norm]; +"339 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__0" [id=339, type=relu_]; +"340 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=340, type=symmetric_quantize]; +"341 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=341, type=symmetric_quantize]; +"342 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=342, type=conv2d]; +"343 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=343, type=symmetric_quantize]; +"344 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" [id=344, type=group_norm]; +"345 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__0" [id=345, type=relu_]; +"346 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=346, type=symmetric_quantize]; +"347 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=347, type=conv2d]; +"348 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=348, type=symmetric_quantize]; +"349 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" [id=349, type=group_norm]; +"350 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__0" [id=350, type=relu_]; +"351 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=351, type=symmetric_quantize]; +"352 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=352, type=symmetric_quantize]; +"353 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=353, type=conv2d]; +"354 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=354, type=symmetric_quantize]; +"355 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" [id=355, type=group_norm]; +"356 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__0" [id=356, type=relu_]; +"357 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=357, type=symmetric_quantize]; +"358 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=358, type=symmetric_quantize]; +"359 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=359, type=conv2d]; +"360 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=360, type=symmetric_quantize]; +"361 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" [id=361, type=group_norm]; +"362 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0" [id=362, type=relu_]; +"363 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=363, type=symmetric_quantize]; +"364 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=364, type=symmetric_quantize]; +"365 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_0" [id=365, type=conv2d]; +"366 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=366, type=symmetric_quantize]; +"367 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_0" [id=367, type=group_norm]; +"368 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__0" [id=368, type=relu_]; +"369 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=369, type=symmetric_quantize]; +"370 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=370, type=symmetric_quantize]; +"371 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_0" [id=371, type=conv2d]; +"372 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_0" [id=372, type=symmetric_quantize]; +"373 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[0]/__mul___0" [id=373, type=__mul__]; +"374 VFNet/VFNetHead[bbox_head]/float_0" [id=374, type=float]; +"375 VFNet/VFNetHead[bbox_head]/exp_0" [id=375, type=exp]; +"376 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_0" [id=376, type=symmetric_quantize]; +"377 VFNet/VFNetHead[bbox_head]/__mul___0" [id=377, type=__mul__]; +"378 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_1" [id=378, type=symmetric_quantize]; +"379 VFNet/VFNetHead[bbox_head]/__rmul___0" [id=379, type=__rmul__]; +"380 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_2" [id=380, type=symmetric_quantize]; +"381 VFNet/VFNetHead[bbox_head]/__radd___0" [id=381, type=__radd__]; +"382 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_3" [id=382, type=symmetric_quantize]; +"383 VFNet/VFNetHead[bbox_head]/__truediv___0" [id=383, type=__truediv__]; +"384 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_4" [id=384, type=symmetric_quantize]; +"385 VFNet/VFNetHead[bbox_head]/__getitem___0" [id=385, type=__getitem__]; +"386 VFNet/VFNetHead[bbox_head]/__getitem___1" [id=386, type=__getitem__]; +"387 VFNet/VFNetHead[bbox_head]/__getitem___2" [id=387, type=__getitem__]; +"388 VFNet/VFNetHead[bbox_head]/__getitem___3" [id=388, type=__getitem__]; +"389 VFNet/VFNetHead[bbox_head]/new_zeros_0" [id=389, type=new_zeros]; +"390 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_5" [id=390, type=symmetric_quantize]; +"391 VFNet/VFNetHead[bbox_head]/__rmul___1" [id=391, type=__rmul__]; +"392 VFNet/VFNetHead[bbox_head]/__rmul___2" [id=392, type=__rmul__]; +"393 VFNet/VFNetHead[bbox_head]/__rmul___3" [id=393, type=__rmul__]; +"394 VFNet/VFNetHead[bbox_head]/__rmul___4" [id=394, type=__rmul__]; +"395 VFNet/VFNetHead[bbox_head]/__rmul___5" [id=395, type=__rmul__]; +"396 VFNet/VFNetHead[bbox_head]/__rmul___6" [id=396, type=__rmul__]; +"397 VFNet/VFNetHead[bbox_head]/__sub___0" [id=397, type=__sub__]; +"398 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_0" [id=398, type=type_as]; +"399 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_0" [id=399, type=new_empty]; +"400 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_0" [id=400, type=symmetric_quantize]; +"401 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_1" [id=401, type=new_empty]; +"402 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_2" [id=402, type=new_empty]; +"403 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__0" [id=403, type=relu_]; +"404 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=404, type=symmetric_quantize]; +"405 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_0" [id=405, type=conv2d]; +"406 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_0" [id=406, type=symmetric_quantize]; +"407 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[0]/__mul___0" [id=407, type=__mul__]; +"408 VFNet/VFNetHead[bbox_head]/float_1" [id=408, type=float]; +"409 VFNet/VFNetHead[bbox_head]/exp_1" [id=409, type=exp]; +"410 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_6" [id=410, type=symmetric_quantize]; +"411 VFNet/VFNetHead[bbox_head]/__mul___1" [id=411, type=__mul__]; +"412 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_0" [id=412, type=type_as]; +"413 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_0" [id=413, type=new_empty]; +"414 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_0" [id=414, type=symmetric_quantize]; +"415 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_1" [id=415, type=new_empty]; +"416 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_2" [id=416, type=new_empty]; +"417 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__1" [id=417, type=relu_]; +"418 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=418, type=symmetric_quantize]; +"419 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_0" [id=419, type=conv2d]; +"420 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=420, type=symmetric_quantize]; +"421 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" [id=421, type=conv2d]; +"422 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=422, type=symmetric_quantize]; +"423 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" [id=423, type=group_norm]; +"424 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__1" [id=424, type=relu_]; +"425 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=425, type=symmetric_quantize]; +"426 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=426, type=symmetric_quantize]; +"427 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" [id=427, type=conv2d]; +"428 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=428, type=symmetric_quantize]; +"429 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" [id=429, type=group_norm]; +"430 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__1" [id=430, type=relu_]; +"431 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=431, type=symmetric_quantize]; +"432 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=432, type=symmetric_quantize]; +"433 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" [id=433, type=conv2d]; +"434 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=434, type=symmetric_quantize]; +"435 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" [id=435, type=group_norm]; +"436 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__1" [id=436, type=relu_]; +"437 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=437, type=symmetric_quantize]; +"438 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" [id=438, type=conv2d]; +"439 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=439, type=symmetric_quantize]; +"440 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" [id=440, type=group_norm]; +"441 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__1" [id=441, type=relu_]; +"442 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=442, type=symmetric_quantize]; +"443 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=443, type=symmetric_quantize]; +"444 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" [id=444, type=conv2d]; +"445 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=445, type=symmetric_quantize]; +"446 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" [id=446, type=group_norm]; +"447 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__1" [id=447, type=relu_]; +"448 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=448, type=symmetric_quantize]; +"449 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=449, type=symmetric_quantize]; +"450 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" [id=450, type=conv2d]; +"451 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=451, type=symmetric_quantize]; +"452 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" [id=452, type=group_norm]; +"453 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1" [id=453, type=relu_]; +"454 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=454, type=symmetric_quantize]; +"455 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=455, type=symmetric_quantize]; +"456 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_1" [id=456, type=conv2d]; +"457 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=457, type=symmetric_quantize]; +"458 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_1" [id=458, type=group_norm]; +"459 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__1" [id=459, type=relu_]; +"460 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" [id=460, type=symmetric_quantize]; +"461 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=461, type=symmetric_quantize]; +"462 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_1" [id=462, type=conv2d]; +"463 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_1" [id=463, type=symmetric_quantize]; +"464 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[1]/__mul___0" [id=464, type=__mul__]; +"465 VFNet/VFNetHead[bbox_head]/float_2" [id=465, type=float]; +"466 VFNet/VFNetHead[bbox_head]/exp_2" [id=466, type=exp]; +"467 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_7" [id=467, type=symmetric_quantize]; +"468 VFNet/VFNetHead[bbox_head]/__mul___2" [id=468, type=__mul__]; +"469 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_8" [id=469, type=symmetric_quantize]; +"470 VFNet/VFNetHead[bbox_head]/__rmul___7" [id=470, type=__rmul__]; +"471 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_9" [id=471, type=symmetric_quantize]; +"472 VFNet/VFNetHead[bbox_head]/__radd___1" [id=472, type=__radd__]; +"473 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_10" [id=473, type=symmetric_quantize]; +"474 VFNet/VFNetHead[bbox_head]/__truediv___1" [id=474, type=__truediv__]; +"475 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_11" [id=475, type=symmetric_quantize]; +"476 VFNet/VFNetHead[bbox_head]/__getitem___4" [id=476, type=__getitem__]; +"477 VFNet/VFNetHead[bbox_head]/__getitem___5" [id=477, type=__getitem__]; +"478 VFNet/VFNetHead[bbox_head]/__getitem___6" [id=478, type=__getitem__]; +"479 VFNet/VFNetHead[bbox_head]/__getitem___7" [id=479, type=__getitem__]; +"480 VFNet/VFNetHead[bbox_head]/new_zeros_1" [id=480, type=new_zeros]; +"481 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_12" [id=481, type=symmetric_quantize]; +"482 VFNet/VFNetHead[bbox_head]/__rmul___8" [id=482, type=__rmul__]; +"483 VFNet/VFNetHead[bbox_head]/__rmul___9" [id=483, type=__rmul__]; +"484 VFNet/VFNetHead[bbox_head]/__rmul___10" [id=484, type=__rmul__]; +"485 VFNet/VFNetHead[bbox_head]/__rmul___11" [id=485, type=__rmul__]; +"486 VFNet/VFNetHead[bbox_head]/__rmul___12" [id=486, type=__rmul__]; +"487 VFNet/VFNetHead[bbox_head]/__rmul___13" [id=487, type=__rmul__]; +"488 VFNet/VFNetHead[bbox_head]/__sub___1" [id=488, type=__sub__]; +"489 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_1" [id=489, type=type_as]; +"490 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_3" [id=490, type=new_empty]; +"491 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_1" [id=491, type=symmetric_quantize]; +"492 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_4" [id=492, type=new_empty]; +"493 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_5" [id=493, type=new_empty]; +"494 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__2" [id=494, type=relu_]; +"495 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=495, type=symmetric_quantize]; +"496 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_1" [id=496, type=conv2d]; +"497 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_1" [id=497, type=symmetric_quantize]; +"498 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[1]/__mul___0" [id=498, type=__mul__]; +"499 VFNet/VFNetHead[bbox_head]/float_3" [id=499, type=float]; +"500 VFNet/VFNetHead[bbox_head]/exp_3" [id=500, type=exp]; +"501 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_13" [id=501, type=symmetric_quantize]; +"502 VFNet/VFNetHead[bbox_head]/__mul___3" [id=502, type=__mul__]; +"503 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_1" [id=503, type=type_as]; +"504 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_3" [id=504, type=new_empty]; +"505 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_1" [id=505, type=symmetric_quantize]; +"506 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_4" [id=506, type=new_empty]; +"507 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_5" [id=507, type=new_empty]; +"508 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__3" [id=508, type=relu_]; +"509 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=509, type=symmetric_quantize]; +"510 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_1" [id=510, type=conv2d]; +"511 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=511, type=symmetric_quantize]; +"512 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" [id=512, type=conv2d]; +"513 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=513, type=symmetric_quantize]; +"514 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" [id=514, type=group_norm]; +"515 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__2" [id=515, type=relu_]; +"516 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=516, type=symmetric_quantize]; +"517 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=517, type=symmetric_quantize]; +"518 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" [id=518, type=conv2d]; +"519 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=519, type=symmetric_quantize]; +"520 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" [id=520, type=group_norm]; +"521 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__2" [id=521, type=relu_]; +"522 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=522, type=symmetric_quantize]; +"523 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=523, type=symmetric_quantize]; +"524 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" [id=524, type=conv2d]; +"525 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=525, type=symmetric_quantize]; +"526 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" [id=526, type=group_norm]; +"527 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__2" [id=527, type=relu_]; +"528 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=528, type=symmetric_quantize]; +"529 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" [id=529, type=conv2d]; +"530 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=530, type=symmetric_quantize]; +"531 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" [id=531, type=group_norm]; +"532 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__2" [id=532, type=relu_]; +"533 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=533, type=symmetric_quantize]; +"534 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=534, type=symmetric_quantize]; +"535 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" [id=535, type=conv2d]; +"536 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=536, type=symmetric_quantize]; +"537 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" [id=537, type=group_norm]; +"538 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__2" [id=538, type=relu_]; +"539 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=539, type=symmetric_quantize]; +"540 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=540, type=symmetric_quantize]; +"541 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" [id=541, type=conv2d]; +"542 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" [id=542, type=symmetric_quantize]; +"543 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" [id=543, type=group_norm]; +"544 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2" [id=544, type=relu_]; +"545 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=545, type=symmetric_quantize]; +"546 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=546, type=symmetric_quantize]; +"547 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_2" [id=547, type=conv2d]; +"548 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_5" [id=548, type=symmetric_quantize]; +"549 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_2" [id=549, type=group_norm]; +"550 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__2" [id=550, type=relu_]; +"551 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" [id=551, type=symmetric_quantize]; +"552 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=552, type=symmetric_quantize]; +"553 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_2" [id=553, type=conv2d]; +"554 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_2" [id=554, type=symmetric_quantize]; +"555 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[2]/__mul___0" [id=555, type=__mul__]; +"556 VFNet/VFNetHead[bbox_head]/float_4" [id=556, type=float]; +"557 VFNet/VFNetHead[bbox_head]/exp_4" [id=557, type=exp]; +"558 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_14" [id=558, type=symmetric_quantize]; +"559 VFNet/VFNetHead[bbox_head]/__mul___4" [id=559, type=__mul__]; +"560 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_15" [id=560, type=symmetric_quantize]; +"561 VFNet/VFNetHead[bbox_head]/__rmul___14" [id=561, type=__rmul__]; +"562 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_16" [id=562, type=symmetric_quantize]; +"563 VFNet/VFNetHead[bbox_head]/__radd___2" [id=563, type=__radd__]; +"564 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_17" [id=564, type=symmetric_quantize]; +"565 VFNet/VFNetHead[bbox_head]/__truediv___2" [id=565, type=__truediv__]; +"566 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_18" [id=566, type=symmetric_quantize]; +"567 VFNet/VFNetHead[bbox_head]/__getitem___8" [id=567, type=__getitem__]; +"568 VFNet/VFNetHead[bbox_head]/__getitem___9" [id=568, type=__getitem__]; +"569 VFNet/VFNetHead[bbox_head]/__getitem___10" [id=569, type=__getitem__]; +"570 VFNet/VFNetHead[bbox_head]/__getitem___11" [id=570, type=__getitem__]; +"571 VFNet/VFNetHead[bbox_head]/new_zeros_2" [id=571, type=new_zeros]; +"572 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_19" [id=572, type=symmetric_quantize]; +"573 VFNet/VFNetHead[bbox_head]/__rmul___15" [id=573, type=__rmul__]; +"574 VFNet/VFNetHead[bbox_head]/__rmul___16" [id=574, type=__rmul__]; +"575 VFNet/VFNetHead[bbox_head]/__rmul___17" [id=575, type=__rmul__]; +"576 VFNet/VFNetHead[bbox_head]/__rmul___18" [id=576, type=__rmul__]; +"577 VFNet/VFNetHead[bbox_head]/__rmul___19" [id=577, type=__rmul__]; +"578 VFNet/VFNetHead[bbox_head]/__rmul___20" [id=578, type=__rmul__]; +"579 VFNet/VFNetHead[bbox_head]/__sub___2" [id=579, type=__sub__]; +"580 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_2" [id=580, type=type_as]; +"581 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_6" [id=581, type=new_empty]; +"582 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_2" [id=582, type=symmetric_quantize]; +"583 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_7" [id=583, type=new_empty]; +"584 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_8" [id=584, type=new_empty]; +"585 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__4" [id=585, type=relu_]; +"586 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=586, type=symmetric_quantize]; +"587 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_2" [id=587, type=conv2d]; +"588 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_2" [id=588, type=symmetric_quantize]; +"589 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[2]/__mul___0" [id=589, type=__mul__]; +"590 VFNet/VFNetHead[bbox_head]/float_5" [id=590, type=float]; +"591 VFNet/VFNetHead[bbox_head]/exp_5" [id=591, type=exp]; +"592 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_20" [id=592, type=symmetric_quantize]; +"593 VFNet/VFNetHead[bbox_head]/__mul___5" [id=593, type=__mul__]; +"594 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_2" [id=594, type=type_as]; +"595 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_6" [id=595, type=new_empty]; +"596 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_2" [id=596, type=symmetric_quantize]; +"597 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_7" [id=597, type=new_empty]; +"598 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_8" [id=598, type=new_empty]; +"599 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__5" [id=599, type=relu_]; +"600 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=600, type=symmetric_quantize]; +"601 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_2" [id=601, type=conv2d]; +"602 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=602, type=symmetric_quantize]; +"603 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" [id=603, type=conv2d]; +"604 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=604, type=symmetric_quantize]; +"605 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" [id=605, type=group_norm]; +"606 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__3" [id=606, type=relu_]; +"607 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=607, type=symmetric_quantize]; +"608 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=608, type=symmetric_quantize]; +"609 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" [id=609, type=conv2d]; +"610 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=610, type=symmetric_quantize]; +"611 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" [id=611, type=group_norm]; +"612 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__3" [id=612, type=relu_]; +"613 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=613, type=symmetric_quantize]; +"614 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=614, type=symmetric_quantize]; +"615 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" [id=615, type=conv2d]; +"616 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=616, type=symmetric_quantize]; +"617 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" [id=617, type=group_norm]; +"618 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__3" [id=618, type=relu_]; +"619 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=619, type=symmetric_quantize]; +"620 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" [id=620, type=conv2d]; +"621 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=621, type=symmetric_quantize]; +"622 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" [id=622, type=group_norm]; +"623 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__3" [id=623, type=relu_]; +"624 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=624, type=symmetric_quantize]; +"625 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=625, type=symmetric_quantize]; +"626 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" [id=626, type=conv2d]; +"627 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=627, type=symmetric_quantize]; +"628 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" [id=628, type=group_norm]; +"629 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__3" [id=629, type=relu_]; +"630 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=630, type=symmetric_quantize]; +"631 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=631, type=symmetric_quantize]; +"632 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" [id=632, type=conv2d]; +"633 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" [id=633, type=symmetric_quantize]; +"634 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" [id=634, type=group_norm]; +"635 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3" [id=635, type=relu_]; +"636 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=636, type=symmetric_quantize]; +"637 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_6" [id=637, type=symmetric_quantize]; +"638 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_3" [id=638, type=conv2d]; +"639 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_7" [id=639, type=symmetric_quantize]; +"640 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_3" [id=640, type=group_norm]; +"641 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__3" [id=641, type=relu_]; +"642 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" [id=642, type=symmetric_quantize]; +"643 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=643, type=symmetric_quantize]; +"644 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_3" [id=644, type=conv2d]; +"645 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_3" [id=645, type=symmetric_quantize]; +"646 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[3]/__mul___0" [id=646, type=__mul__]; +"647 VFNet/VFNetHead[bbox_head]/float_6" [id=647, type=float]; +"648 VFNet/VFNetHead[bbox_head]/exp_6" [id=648, type=exp]; +"649 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_21" [id=649, type=symmetric_quantize]; +"650 VFNet/VFNetHead[bbox_head]/__mul___6" [id=650, type=__mul__]; +"651 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_22" [id=651, type=symmetric_quantize]; +"652 VFNet/VFNetHead[bbox_head]/__rmul___21" [id=652, type=__rmul__]; +"653 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_23" [id=653, type=symmetric_quantize]; +"654 VFNet/VFNetHead[bbox_head]/__radd___3" [id=654, type=__radd__]; +"655 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_24" [id=655, type=symmetric_quantize]; +"656 VFNet/VFNetHead[bbox_head]/__truediv___3" [id=656, type=__truediv__]; +"657 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_25" [id=657, type=symmetric_quantize]; +"658 VFNet/VFNetHead[bbox_head]/__getitem___12" [id=658, type=__getitem__]; +"659 VFNet/VFNetHead[bbox_head]/__getitem___13" [id=659, type=__getitem__]; +"660 VFNet/VFNetHead[bbox_head]/__getitem___14" [id=660, type=__getitem__]; +"661 VFNet/VFNetHead[bbox_head]/__getitem___15" [id=661, type=__getitem__]; +"662 VFNet/VFNetHead[bbox_head]/new_zeros_3" [id=662, type=new_zeros]; +"663 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_26" [id=663, type=symmetric_quantize]; +"664 VFNet/VFNetHead[bbox_head]/__rmul___22" [id=664, type=__rmul__]; +"665 VFNet/VFNetHead[bbox_head]/__rmul___23" [id=665, type=__rmul__]; +"666 VFNet/VFNetHead[bbox_head]/__rmul___24" [id=666, type=__rmul__]; +"667 VFNet/VFNetHead[bbox_head]/__rmul___25" [id=667, type=__rmul__]; +"668 VFNet/VFNetHead[bbox_head]/__rmul___26" [id=668, type=__rmul__]; +"669 VFNet/VFNetHead[bbox_head]/__rmul___27" [id=669, type=__rmul__]; +"670 VFNet/VFNetHead[bbox_head]/__sub___3" [id=670, type=__sub__]; +"671 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_3" [id=671, type=type_as]; +"672 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_9" [id=672, type=new_empty]; +"673 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_3" [id=673, type=symmetric_quantize]; +"674 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_10" [id=674, type=new_empty]; +"675 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_11" [id=675, type=new_empty]; +"676 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__6" [id=676, type=relu_]; +"677 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=677, type=symmetric_quantize]; +"678 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_3" [id=678, type=conv2d]; +"679 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_3" [id=679, type=symmetric_quantize]; +"680 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[3]/__mul___0" [id=680, type=__mul__]; +"681 VFNet/VFNetHead[bbox_head]/float_7" [id=681, type=float]; +"682 VFNet/VFNetHead[bbox_head]/exp_7" [id=682, type=exp]; +"683 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_27" [id=683, type=symmetric_quantize]; +"684 VFNet/VFNetHead[bbox_head]/__mul___7" [id=684, type=__mul__]; +"685 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_3" [id=685, type=type_as]; +"686 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_9" [id=686, type=new_empty]; +"687 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_3" [id=687, type=symmetric_quantize]; +"688 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_10" [id=688, type=new_empty]; +"689 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_11" [id=689, type=new_empty]; +"690 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__7" [id=690, type=relu_]; +"691 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=691, type=symmetric_quantize]; +"692 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_3" [id=692, type=conv2d]; +"693 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=693, type=symmetric_quantize]; +"694 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" [id=694, type=conv2d]; +"695 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=695, type=symmetric_quantize]; +"696 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" [id=696, type=group_norm]; +"697 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__4" [id=697, type=relu_]; +"698 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=698, type=symmetric_quantize]; +"699 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=699, type=symmetric_quantize]; +"700 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" [id=700, type=conv2d]; +"701 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=701, type=symmetric_quantize]; +"702 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" [id=702, type=group_norm]; +"703 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__4" [id=703, type=relu_]; +"704 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=704, type=symmetric_quantize]; +"705 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=705, type=symmetric_quantize]; +"706 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" [id=706, type=conv2d]; +"707 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=707, type=symmetric_quantize]; +"708 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" [id=708, type=group_norm]; +"709 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__4" [id=709, type=relu_]; +"710 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=710, type=symmetric_quantize]; +"711 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" [id=711, type=conv2d]; +"712 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=712, type=symmetric_quantize]; +"713 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" [id=713, type=group_norm]; +"714 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__4" [id=714, type=relu_]; +"715 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=715, type=symmetric_quantize]; +"716 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=716, type=symmetric_quantize]; +"717 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" [id=717, type=conv2d]; +"718 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=718, type=symmetric_quantize]; +"719 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" [id=719, type=group_norm]; +"720 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__4" [id=720, type=relu_]; +"721 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=721, type=symmetric_quantize]; +"722 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=722, type=symmetric_quantize]; +"723 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" [id=723, type=conv2d]; +"724 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" [id=724, type=symmetric_quantize]; +"725 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" [id=725, type=group_norm]; +"726 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4" [id=726, type=relu_]; +"727 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=727, type=symmetric_quantize]; +"728 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_8" [id=728, type=symmetric_quantize]; +"729 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_4" [id=729, type=conv2d]; +"730 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_9" [id=730, type=symmetric_quantize]; +"731 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_4" [id=731, type=group_norm]; +"732 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__4" [id=732, type=relu_]; +"733 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" [id=733, type=symmetric_quantize]; +"734 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=734, type=symmetric_quantize]; +"735 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_4" [id=735, type=conv2d]; +"736 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_4" [id=736, type=symmetric_quantize]; +"737 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[4]/__mul___0" [id=737, type=__mul__]; +"738 VFNet/VFNetHead[bbox_head]/float_8" [id=738, type=float]; +"739 VFNet/VFNetHead[bbox_head]/exp_8" [id=739, type=exp]; +"740 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_28" [id=740, type=symmetric_quantize]; +"741 VFNet/VFNetHead[bbox_head]/__mul___8" [id=741, type=__mul__]; +"742 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_29" [id=742, type=symmetric_quantize]; +"743 VFNet/VFNetHead[bbox_head]/__rmul___28" [id=743, type=__rmul__]; +"744 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_30" [id=744, type=symmetric_quantize]; +"745 VFNet/VFNetHead[bbox_head]/__radd___4" [id=745, type=__radd__]; +"746 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_31" [id=746, type=symmetric_quantize]; +"747 VFNet/VFNetHead[bbox_head]/__truediv___4" [id=747, type=__truediv__]; +"748 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_32" [id=748, type=symmetric_quantize]; +"749 VFNet/VFNetHead[bbox_head]/__getitem___16" [id=749, type=__getitem__]; +"750 VFNet/VFNetHead[bbox_head]/__getitem___17" [id=750, type=__getitem__]; +"751 VFNet/VFNetHead[bbox_head]/__getitem___18" [id=751, type=__getitem__]; +"752 VFNet/VFNetHead[bbox_head]/__getitem___19" [id=752, type=__getitem__]; +"753 VFNet/VFNetHead[bbox_head]/new_zeros_4" [id=753, type=new_zeros]; +"754 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_33" [id=754, type=symmetric_quantize]; +"755 VFNet/VFNetHead[bbox_head]/__rmul___29" [id=755, type=__rmul__]; +"756 VFNet/VFNetHead[bbox_head]/__rmul___30" [id=756, type=__rmul__]; +"757 VFNet/VFNetHead[bbox_head]/__rmul___31" [id=757, type=__rmul__]; +"758 VFNet/VFNetHead[bbox_head]/__rmul___32" [id=758, type=__rmul__]; +"759 VFNet/VFNetHead[bbox_head]/__rmul___33" [id=759, type=__rmul__]; +"760 VFNet/VFNetHead[bbox_head]/__rmul___34" [id=760, type=__rmul__]; +"761 VFNet/VFNetHead[bbox_head]/__sub___4" [id=761, type=__sub__]; +"762 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_4" [id=762, type=type_as]; +"763 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_12" [id=763, type=new_empty]; +"764 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_4" [id=764, type=symmetric_quantize]; +"765 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_13" [id=765, type=new_empty]; +"766 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_14" [id=766, type=new_empty]; +"767 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__8" [id=767, type=relu_]; +"768 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=768, type=symmetric_quantize]; +"769 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_4" [id=769, type=conv2d]; +"770 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_4" [id=770, type=symmetric_quantize]; +"771 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[4]/__mul___0" [id=771, type=__mul__]; +"772 VFNet/VFNetHead[bbox_head]/float_9" [id=772, type=float]; +"773 VFNet/VFNetHead[bbox_head]/exp_9" [id=773, type=exp]; +"774 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_34" [id=774, type=symmetric_quantize]; +"775 VFNet/VFNetHead[bbox_head]/__mul___9" [id=775, type=__mul__]; +"776 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_4" [id=776, type=type_as]; +"777 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_12" [id=777, type=new_empty]; +"778 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_4" [id=778, type=symmetric_quantize]; +"779 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_13" [id=779, type=new_empty]; +"780 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_14" [id=780, type=new_empty]; +"781 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__9" [id=781, type=relu_]; +"782 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=782, type=symmetric_quantize]; +"783 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_4" [id=783, type=conv2d]; +"0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 VFNet/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0"; +"2 VFNet/ResNet[backbone]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 VFNet/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0"; +"3 VFNet/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0" -> "4 VFNet/ResNet[backbone]/NNCFBatchNorm[bn1]/batch_norm_0"; +"4 VFNet/ResNet[backbone]/NNCFBatchNorm[bn1]/batch_norm_0" -> "5 VFNet/ResNet[backbone]/ReLU[relu]/relu__0"; +"5 VFNet/ResNet[backbone]/ReLU[relu]/relu__0" -> "6 VFNet/ResNet[backbone]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"6 VFNet/ResNet[backbone]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "7 VFNet/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0"; +"7 VFNet/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0" -> "9 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"7 VFNet/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0" -> "23 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"8 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "9 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"9 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "10 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0"; +"10 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" -> "11 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__0"; +"11 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__0" -> "12 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"12 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "14 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"13 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"14 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "15 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0"; +"15 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" -> "16 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__1"; +"16 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__1" -> "17 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"17 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "19 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"18 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "19 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"19 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "20 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0"; +"20 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" -> "21 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"21 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "26 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0"; +"22 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "23 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"23 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "24 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0"; +"24 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" -> "25 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0"; +"25 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" -> "26 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0"; +"26 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0" -> "27 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__2"; +"27 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__2" -> "28 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"28 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "30 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"28 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "43 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0"; +"29 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "30 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"30 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "31 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0"; +"31 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" -> "32 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__0"; +"32 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__0" -> "33 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"33 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "35 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"34 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "35 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"35 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "36 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0"; +"36 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" -> "37 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__1"; +"37 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__1" -> "38 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"38 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "40 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"39 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "40 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"40 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "41 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0"; +"41 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" -> "42 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"42 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "43 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0"; +"43 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0" -> "44 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__2"; +"44 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__2" -> "45 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"45 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "47 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"45 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "60 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0"; +"46 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "47 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"47 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "48 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0"; +"48 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" -> "49 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__0"; +"49 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__0" -> "50 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"50 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "52 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"51 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"52 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "53 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0"; +"53 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" -> "54 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__1"; +"54 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__1" -> "55 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"55 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "57 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"56 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"57 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "58 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0"; +"58 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" -> "59 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"59 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "60 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0"; +"60 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0" -> "61 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__2"; +"61 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__2" -> "62 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"62 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "64 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"62 VFNet/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "78 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"63 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "64 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"64 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "65 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0"; +"65 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" -> "66 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__0"; +"66 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__0" -> "67 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"67 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "69 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"68 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "69 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"69 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "70 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0"; +"70 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" -> "71 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__1"; +"71 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__1" -> "72 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"72 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "74 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"73 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "74 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"74 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "75 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0"; +"75 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" -> "76 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"76 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "81 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0"; +"77 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "78 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"78 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "79 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0"; +"79 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" -> "80 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0"; +"80 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" -> "81 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0"; +"81 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0" -> "82 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__2"; +"82 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__2" -> "83 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"83 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "85 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"83 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "98 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0"; +"84 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "85 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"85 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "86 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0"; +"86 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" -> "87 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__0"; +"87 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__0" -> "88 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"88 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "90 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"89 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "90 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"90 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "91 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0"; +"91 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" -> "92 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__1"; +"92 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__1" -> "93 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"93 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "95 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"94 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "95 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"95 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "96 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0"; +"96 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" -> "97 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"97 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "98 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0"; +"98 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0" -> "99 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__2"; +"99 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__2" -> "100 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"100 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "102 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"100 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "115 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0"; +"101 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "102 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"102 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "103 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0"; +"103 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" -> "104 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__0"; +"104 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__0" -> "105 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"105 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "107 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"106 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "107 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"107 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "108 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0"; +"108 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" -> "109 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__1"; +"109 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__1" -> "110 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"110 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "112 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"111 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"112 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "113 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0"; +"113 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" -> "114 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"114 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "115 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0"; +"115 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0" -> "116 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__2"; +"116 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__2" -> "117 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"117 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "119 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"117 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "132 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0"; +"118 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "119 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"119 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "120 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn1]/batch_norm_0"; +"120 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn1]/batch_norm_0" -> "121 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__0"; +"121 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__0" -> "122 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"122 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "124 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"123 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "124 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"124 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "125 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn2]/batch_norm_0"; +"125 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn2]/batch_norm_0" -> "126 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__1"; +"126 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__1" -> "127 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"127 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "129 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"128 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "129 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"129 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" -> "130 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn3]/batch_norm_0"; +"130 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn3]/batch_norm_0" -> "131 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"131 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "132 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0"; +"132 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0" -> "133 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__2"; +"133 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__2" -> "134 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"134 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "136 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"134 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "150 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"134 VFNet/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "297 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"135 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "136 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"136 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "137 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0"; +"137 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" -> "138 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__0"; +"138 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__0" -> "139 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"139 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "141 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"140 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "141 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"141 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "142 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0"; +"142 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" -> "143 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__1"; +"143 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__1" -> "144 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"144 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "146 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"145 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "146 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"146 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "147 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0"; +"147 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" -> "148 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"148 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "153 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0"; +"149 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "150 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"150 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "151 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0"; +"151 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" -> "152 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0"; +"152 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" -> "153 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0"; +"153 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0" -> "154 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__2"; +"154 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__2" -> "155 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"155 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "157 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"155 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "170 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0"; +"156 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "157 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"157 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "158 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0"; +"158 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" -> "159 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__0"; +"159 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__0" -> "160 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"160 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "162 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"161 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "162 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"162 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "163 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0"; +"163 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" -> "164 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__1"; +"164 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__1" -> "165 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"165 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "167 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"166 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "167 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"167 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "168 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0"; +"168 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" -> "169 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"169 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "170 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0"; +"170 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0" -> "171 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__2"; +"171 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__2" -> "172 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"172 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "174 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"172 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "187 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0"; +"173 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "174 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"174 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "175 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0"; +"175 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" -> "176 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__0"; +"176 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__0" -> "177 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"177 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "179 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"178 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "179 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"179 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "180 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0"; +"180 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" -> "181 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__1"; +"181 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__1" -> "182 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"182 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "184 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"183 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "184 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"184 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "185 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0"; +"185 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" -> "186 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"186 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "187 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0"; +"187 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0" -> "188 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__2"; +"188 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__2" -> "189 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"189 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "191 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"189 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "204 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0"; +"190 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "191 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"191 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "192 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn1]/batch_norm_0"; +"192 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn1]/batch_norm_0" -> "193 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__0"; +"193 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__0" -> "194 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"194 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "196 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"195 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "196 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"196 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "197 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn2]/batch_norm_0"; +"197 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn2]/batch_norm_0" -> "198 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__1"; +"198 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__1" -> "199 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"199 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "201 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"200 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "201 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"201 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" -> "202 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn3]/batch_norm_0"; +"202 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn3]/batch_norm_0" -> "203 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"203 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "204 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0"; +"204 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0" -> "205 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__2"; +"205 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__2" -> "206 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"206 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "208 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; +"206 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "221 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0"; +"207 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "208 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; +"208 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "209 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn1]/batch_norm_0"; +"209 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn1]/batch_norm_0" -> "210 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__0"; +"210 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__0" -> "211 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"211 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "213 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; +"212 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "213 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; +"213 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "214 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn2]/batch_norm_0"; +"214 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn2]/batch_norm_0" -> "215 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__1"; +"215 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__1" -> "216 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"216 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "218 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0"; +"217 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "218 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0"; +"218 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0" -> "219 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn3]/batch_norm_0"; +"219 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn3]/batch_norm_0" -> "220 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"220 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "221 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0"; +"221 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0" -> "222 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__2"; +"222 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__2" -> "223 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"223 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "225 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; +"223 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "238 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0"; +"224 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; +"225 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "226 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn1]/batch_norm_0"; +"226 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn1]/batch_norm_0" -> "227 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__0"; +"227 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__0" -> "228 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"228 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "230 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; +"229 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "230 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; +"230 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "231 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn2]/batch_norm_0"; +"231 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn2]/batch_norm_0" -> "232 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__1"; +"232 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__1" -> "233 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"233 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "235 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0"; +"234 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "235 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0"; +"235 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0" -> "236 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn3]/batch_norm_0"; +"236 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn3]/batch_norm_0" -> "237 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"237 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "238 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0"; +"238 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0" -> "239 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__2"; +"239 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__2" -> "240 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"240 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "242 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"240 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "256 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"240 VFNet/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "300 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"241 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "242 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"242 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "243 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0"; +"243 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn1]/batch_norm_0" -> "244 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__0"; +"244 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__0" -> "245 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"245 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "247 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"246 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "247 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"247 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "248 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0"; +"248 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn2]/batch_norm_0" -> "249 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__1"; +"249 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__1" -> "250 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"250 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "252 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"251 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "252 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"252 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "253 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0"; +"253 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn3]/batch_norm_0" -> "254 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"254 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "259 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0"; +"255 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "256 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"256 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "257 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0"; +"257 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/batch_norm_0" -> "258 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0"; +"258 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm[1]/SymmetricQuantizer/symmetric_quantize_0" -> "259 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0"; +"259 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0" -> "260 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__2"; +"260 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__2" -> "261 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"261 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "263 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"261 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "276 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0"; +"262 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "263 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"263 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "264 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0"; +"264 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn1]/batch_norm_0" -> "265 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__0"; +"265 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__0" -> "266 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"266 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "268 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"267 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "268 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"268 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "269 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0"; +"269 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn2]/batch_norm_0" -> "270 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__1"; +"270 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__1" -> "271 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"271 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "273 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"272 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "273 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"273 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "274 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0"; +"274 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn3]/batch_norm_0" -> "275 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"275 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "276 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0"; +"276 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0" -> "277 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__2"; +"277 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__2" -> "278 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"278 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "280 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"278 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "293 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0"; +"279 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "280 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"280 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "281 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0"; +"281 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn1]/batch_norm_0" -> "282 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__0"; +"282 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__0" -> "283 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"283 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "285 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"284 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "285 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"285 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "286 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0"; +"286 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn2]/batch_norm_0" -> "287 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__1"; +"287 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__1" -> "288 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"288 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "290 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"289 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "290 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"290 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "291 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0"; +"291 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn3]/batch_norm_0" -> "292 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"292 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "293 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0"; +"293 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0" -> "294 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__2"; +"294 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__2" -> "295 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"295 VFNet/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "303 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"296 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "297 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"297 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "298 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"298 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "311 VFNet/FPN[neck]/__iadd___1"; +"299 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "300 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"300 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "301 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"301 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "307 VFNet/FPN[neck]/__iadd___0"; +"302 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "303 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"303 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "304 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"304 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "305 VFNet/FPN[neck]/interpolate_0"; +"304 VFNet/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "320 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"305 VFNet/FPN[neck]/interpolate_0" -> "306 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0"; +"306 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" -> "307 VFNet/FPN[neck]/__iadd___0"; +"307 VFNet/FPN[neck]/__iadd___0" -> "308 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1"; +"308 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "309 VFNet/FPN[neck]/interpolate_1"; +"308 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "317 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"309 VFNet/FPN[neck]/interpolate_1" -> "310 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2"; +"310 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" -> "311 VFNet/FPN[neck]/__iadd___1"; +"311 VFNet/FPN[neck]/__iadd___1" -> "312 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3"; +"312 VFNet/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" -> "314 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"313 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "314 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"314 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "315 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"315 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "330 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"315 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "347 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"316 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "317 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"317 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "318 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"318 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "421 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"318 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "438 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"319 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "320 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"320 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "321 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"321 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "323 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"321 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "512 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"321 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "529 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"322 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "323 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"323 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "324 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"324 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "325 VFNet/FPN[neck]/relu_0"; +"324 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "603 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"324 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "620 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"325 VFNet/FPN[neck]/relu_0" -> "327 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0"; +"326 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "327 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0"; +"327 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/conv2d_0" -> "328 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"328 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "694 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"328 VFNet/FPN[neck]/ModuleList[fpn_convs]/ConvModule[4]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "711 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"329 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "330 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"330 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "331 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"331 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "332 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0"; +"332 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" -> "333 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__0"; +"333 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__0" -> "334 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"334 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "336 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"335 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "336 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"336 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "337 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"337 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "338 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0"; +"338 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" -> "339 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__0"; +"339 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__0" -> "340 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"340 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "342 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"341 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "342 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"342 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "343 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"343 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "344 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0"; +"344 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" -> "345 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__0"; +"345 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "412 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_0"; +"346 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "347 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"347 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "348 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"348 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "349 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0"; +"349 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_0" -> "350 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__0"; +"350 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__0" -> "351 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"351 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "353 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"352 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "353 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"353 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "354 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"354 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "355 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0"; +"355 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_0" -> "356 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__0"; +"356 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__0" -> "357 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"357 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "359 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"358 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "359 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"359 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "360 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"360 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "361 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0"; +"361 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_0" -> "362 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0"; +"362 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "364 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"362 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "398 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_0"; +"363 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "365 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_0"; +"364 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "365 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_0"; +"365 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_0" -> "366 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"366 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "367 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_0"; +"367 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_0" -> "368 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__0"; +"368 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__0" -> "369 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"369 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "371 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_0"; +"370 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "371 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_0"; +"371 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_0" -> "372 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_0"; +"372 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_0" -> "373 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[0]/__mul___0"; +"373 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[0]/__mul___0" -> "374 VFNet/VFNetHead[bbox_head]/float_0"; +"374 VFNet/VFNetHead[bbox_head]/float_0" -> "375 VFNet/VFNetHead[bbox_head]/exp_0"; +"375 VFNet/VFNetHead[bbox_head]/exp_0" -> "376 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_0"; +"376 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_0" -> "377 VFNet/VFNetHead[bbox_head]/__mul___0"; +"377 VFNet/VFNetHead[bbox_head]/__mul___0" -> "378 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_1"; +"377 VFNet/VFNetHead[bbox_head]/__mul___0" -> "389 VFNet/VFNetHead[bbox_head]/new_zeros_0"; +"378 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_1" -> "379 VFNet/VFNetHead[bbox_head]/__rmul___0"; +"379 VFNet/VFNetHead[bbox_head]/__rmul___0" -> "380 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_2"; +"380 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_2" -> "381 VFNet/VFNetHead[bbox_head]/__radd___0"; +"381 VFNet/VFNetHead[bbox_head]/__radd___0" -> "382 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_3"; +"382 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_3" -> "383 VFNet/VFNetHead[bbox_head]/__truediv___0"; +"383 VFNet/VFNetHead[bbox_head]/__truediv___0" -> "384 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_4"; +"384 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_4" -> "385 VFNet/VFNetHead[bbox_head]/__getitem___0"; +"384 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_4" -> "386 VFNet/VFNetHead[bbox_head]/__getitem___1"; +"384 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_4" -> "387 VFNet/VFNetHead[bbox_head]/__getitem___2"; +"384 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_4" -> "388 VFNet/VFNetHead[bbox_head]/__getitem___3"; +"385 VFNet/VFNetHead[bbox_head]/__getitem___0" -> "392 VFNet/VFNetHead[bbox_head]/__rmul___2"; +"385 VFNet/VFNetHead[bbox_head]/__getitem___0" -> "395 VFNet/VFNetHead[bbox_head]/__rmul___5"; +"385 VFNet/VFNetHead[bbox_head]/__getitem___0" -> "396 VFNet/VFNetHead[bbox_head]/__rmul___6"; +"386 VFNet/VFNetHead[bbox_head]/__getitem___1" -> "391 VFNet/VFNetHead[bbox_head]/__rmul___1"; +"386 VFNet/VFNetHead[bbox_head]/__getitem___1" -> "393 VFNet/VFNetHead[bbox_head]/__rmul___3"; +"386 VFNet/VFNetHead[bbox_head]/__getitem___1" -> "394 VFNet/VFNetHead[bbox_head]/__rmul___4"; +"389 VFNet/VFNetHead[bbox_head]/new_zeros_0" -> "390 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_5"; +"390 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_5" -> "397 VFNet/VFNetHead[bbox_head]/__sub___0"; +"397 VFNet/VFNetHead[bbox_head]/__sub___0" -> "398 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_0"; +"397 VFNet/VFNetHead[bbox_head]/__sub___0" -> "412 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_0"; +"398 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_0" -> "399 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_0"; +"398 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_0" -> "401 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_1"; +"398 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_0" -> "402 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_2"; +"399 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_0" -> "400 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_0"; +"400 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_0" -> "403 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__0"; +"403 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__0" -> "405 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_0"; +"404 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "405 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_0"; +"405 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_0" -> "406 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_0"; +"406 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_0" -> "407 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[0]/__mul___0"; +"407 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[0]/__mul___0" -> "408 VFNet/VFNetHead[bbox_head]/float_1"; +"408 VFNet/VFNetHead[bbox_head]/float_1" -> "409 VFNet/VFNetHead[bbox_head]/exp_1"; +"409 VFNet/VFNetHead[bbox_head]/exp_1" -> "410 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_6"; +"410 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_6" -> "411 VFNet/VFNetHead[bbox_head]/__mul___1"; +"412 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_0" -> "413 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_0"; +"412 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_0" -> "415 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_1"; +"412 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_0" -> "416 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_2"; +"413 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_0" -> "414 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_0"; +"414 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_0" -> "417 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__1"; +"417 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__1" -> "419 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_0"; +"418 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "419 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_0"; +"420 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "421 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"421 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" -> "422 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"422 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "423 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1"; +"423 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" -> "424 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__1"; +"424 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__1" -> "425 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"425 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "427 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"426 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "427 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"427 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" -> "428 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"428 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "429 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1"; +"429 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" -> "430 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__1"; +"430 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__1" -> "431 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"431 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "433 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"432 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "433 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"433 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" -> "434 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"434 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "435 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1"; +"435 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" -> "436 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__1"; +"436 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__1" -> "503 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_1"; +"437 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "438 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1"; +"438 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_1" -> "439 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"439 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "440 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1"; +"440 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_1" -> "441 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__1"; +"441 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__1" -> "442 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"442 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "444 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"443 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "444 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1"; +"444 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_1" -> "445 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"445 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "446 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1"; +"446 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_1" -> "447 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__1"; +"447 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__1" -> "448 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"448 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "450 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"449 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "450 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1"; +"450 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_1" -> "451 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"451 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "452 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1"; +"452 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_1" -> "453 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1"; +"453 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1" -> "455 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"453 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__1" -> "489 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_1"; +"454 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "456 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_1"; +"455 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "456 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_1"; +"456 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_1" -> "457 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"457 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "458 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_1"; +"458 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_1" -> "459 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__1"; +"459 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__1" -> "460 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1"; +"460 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_1" -> "462 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_1"; +"461 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "462 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_1"; +"462 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_1" -> "463 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_1"; +"463 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_1" -> "464 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[1]/__mul___0"; +"464 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[1]/__mul___0" -> "465 VFNet/VFNetHead[bbox_head]/float_2"; +"465 VFNet/VFNetHead[bbox_head]/float_2" -> "466 VFNet/VFNetHead[bbox_head]/exp_2"; +"466 VFNet/VFNetHead[bbox_head]/exp_2" -> "467 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_7"; +"467 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_7" -> "468 VFNet/VFNetHead[bbox_head]/__mul___2"; +"468 VFNet/VFNetHead[bbox_head]/__mul___2" -> "469 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_8"; +"468 VFNet/VFNetHead[bbox_head]/__mul___2" -> "480 VFNet/VFNetHead[bbox_head]/new_zeros_1"; +"469 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_8" -> "470 VFNet/VFNetHead[bbox_head]/__rmul___7"; +"470 VFNet/VFNetHead[bbox_head]/__rmul___7" -> "471 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_9"; +"471 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_9" -> "472 VFNet/VFNetHead[bbox_head]/__radd___1"; +"472 VFNet/VFNetHead[bbox_head]/__radd___1" -> "473 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_10"; +"473 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_10" -> "474 VFNet/VFNetHead[bbox_head]/__truediv___1"; +"474 VFNet/VFNetHead[bbox_head]/__truediv___1" -> "475 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_11"; +"475 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_11" -> "476 VFNet/VFNetHead[bbox_head]/__getitem___4"; +"475 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_11" -> "477 VFNet/VFNetHead[bbox_head]/__getitem___5"; +"475 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_11" -> "478 VFNet/VFNetHead[bbox_head]/__getitem___6"; +"475 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_11" -> "479 VFNet/VFNetHead[bbox_head]/__getitem___7"; +"476 VFNet/VFNetHead[bbox_head]/__getitem___4" -> "483 VFNet/VFNetHead[bbox_head]/__rmul___9"; +"476 VFNet/VFNetHead[bbox_head]/__getitem___4" -> "486 VFNet/VFNetHead[bbox_head]/__rmul___12"; +"476 VFNet/VFNetHead[bbox_head]/__getitem___4" -> "487 VFNet/VFNetHead[bbox_head]/__rmul___13"; +"477 VFNet/VFNetHead[bbox_head]/__getitem___5" -> "482 VFNet/VFNetHead[bbox_head]/__rmul___8"; +"477 VFNet/VFNetHead[bbox_head]/__getitem___5" -> "484 VFNet/VFNetHead[bbox_head]/__rmul___10"; +"477 VFNet/VFNetHead[bbox_head]/__getitem___5" -> "485 VFNet/VFNetHead[bbox_head]/__rmul___11"; +"480 VFNet/VFNetHead[bbox_head]/new_zeros_1" -> "481 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_12"; +"481 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_12" -> "488 VFNet/VFNetHead[bbox_head]/__sub___1"; +"488 VFNet/VFNetHead[bbox_head]/__sub___1" -> "489 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_1"; +"488 VFNet/VFNetHead[bbox_head]/__sub___1" -> "503 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_1"; +"489 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_1" -> "490 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_3"; +"489 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_1" -> "492 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_4"; +"489 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_1" -> "493 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_5"; +"490 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_3" -> "491 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_1"; +"491 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_1" -> "494 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__2"; +"494 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__2" -> "496 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_1"; +"495 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "496 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_1"; +"496 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_1" -> "497 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_1"; +"497 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_1" -> "498 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[1]/__mul___0"; +"498 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[1]/__mul___0" -> "499 VFNet/VFNetHead[bbox_head]/float_3"; +"499 VFNet/VFNetHead[bbox_head]/float_3" -> "500 VFNet/VFNetHead[bbox_head]/exp_3"; +"500 VFNet/VFNetHead[bbox_head]/exp_3" -> "501 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_13"; +"501 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_13" -> "502 VFNet/VFNetHead[bbox_head]/__mul___3"; +"503 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_1" -> "504 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_3"; +"503 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_1" -> "506 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_4"; +"503 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_1" -> "507 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_5"; +"504 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_3" -> "505 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_1"; +"505 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_1" -> "508 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__3"; +"508 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__3" -> "510 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_1"; +"509 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "510 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_1"; +"511 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "512 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"512 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" -> "513 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"513 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "514 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2"; +"514 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" -> "515 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__2"; +"515 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__2" -> "516 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"516 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "518 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"517 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "518 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"518 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" -> "519 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"519 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "520 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2"; +"520 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" -> "521 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__2"; +"521 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__2" -> "522 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"522 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "524 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"523 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "524 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"524 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" -> "525 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"525 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "526 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2"; +"526 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" -> "527 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__2"; +"527 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__2" -> "594 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_2"; +"528 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "529 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2"; +"529 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_2" -> "530 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"530 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "531 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2"; +"531 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_2" -> "532 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__2"; +"532 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__2" -> "533 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"533 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "535 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"534 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "535 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2"; +"535 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_2" -> "536 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"536 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "537 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2"; +"537 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_2" -> "538 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__2"; +"538 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__2" -> "539 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"539 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "541 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"540 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "541 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2"; +"541 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_2" -> "542 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2"; +"542 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_2" -> "543 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2"; +"543 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_2" -> "544 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2"; +"544 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2" -> "546 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"544 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__2" -> "580 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_2"; +"545 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "547 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_2"; +"546 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "547 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_2"; +"547 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_2" -> "548 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_5"; +"548 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_5" -> "549 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_2"; +"549 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_2" -> "550 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__2"; +"550 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__2" -> "551 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2"; +"551 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_2" -> "553 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_2"; +"552 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "553 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_2"; +"553 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_2" -> "554 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_2"; +"554 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_2" -> "555 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[2]/__mul___0"; +"555 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[2]/__mul___0" -> "556 VFNet/VFNetHead[bbox_head]/float_4"; +"556 VFNet/VFNetHead[bbox_head]/float_4" -> "557 VFNet/VFNetHead[bbox_head]/exp_4"; +"557 VFNet/VFNetHead[bbox_head]/exp_4" -> "558 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_14"; +"558 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_14" -> "559 VFNet/VFNetHead[bbox_head]/__mul___4"; +"559 VFNet/VFNetHead[bbox_head]/__mul___4" -> "560 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_15"; +"559 VFNet/VFNetHead[bbox_head]/__mul___4" -> "571 VFNet/VFNetHead[bbox_head]/new_zeros_2"; +"560 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_15" -> "561 VFNet/VFNetHead[bbox_head]/__rmul___14"; +"561 VFNet/VFNetHead[bbox_head]/__rmul___14" -> "562 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_16"; +"562 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_16" -> "563 VFNet/VFNetHead[bbox_head]/__radd___2"; +"563 VFNet/VFNetHead[bbox_head]/__radd___2" -> "564 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_17"; +"564 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_17" -> "565 VFNet/VFNetHead[bbox_head]/__truediv___2"; +"565 VFNet/VFNetHead[bbox_head]/__truediv___2" -> "566 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_18"; +"566 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_18" -> "567 VFNet/VFNetHead[bbox_head]/__getitem___8"; +"566 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_18" -> "568 VFNet/VFNetHead[bbox_head]/__getitem___9"; +"566 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_18" -> "569 VFNet/VFNetHead[bbox_head]/__getitem___10"; +"566 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_18" -> "570 VFNet/VFNetHead[bbox_head]/__getitem___11"; +"567 VFNet/VFNetHead[bbox_head]/__getitem___8" -> "574 VFNet/VFNetHead[bbox_head]/__rmul___16"; +"567 VFNet/VFNetHead[bbox_head]/__getitem___8" -> "577 VFNet/VFNetHead[bbox_head]/__rmul___19"; +"567 VFNet/VFNetHead[bbox_head]/__getitem___8" -> "578 VFNet/VFNetHead[bbox_head]/__rmul___20"; +"568 VFNet/VFNetHead[bbox_head]/__getitem___9" -> "573 VFNet/VFNetHead[bbox_head]/__rmul___15"; +"568 VFNet/VFNetHead[bbox_head]/__getitem___9" -> "575 VFNet/VFNetHead[bbox_head]/__rmul___17"; +"568 VFNet/VFNetHead[bbox_head]/__getitem___9" -> "576 VFNet/VFNetHead[bbox_head]/__rmul___18"; +"571 VFNet/VFNetHead[bbox_head]/new_zeros_2" -> "572 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_19"; +"572 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_19" -> "579 VFNet/VFNetHead[bbox_head]/__sub___2"; +"579 VFNet/VFNetHead[bbox_head]/__sub___2" -> "580 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_2"; +"579 VFNet/VFNetHead[bbox_head]/__sub___2" -> "594 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_2"; +"580 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_2" -> "581 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_6"; +"580 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_2" -> "583 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_7"; +"580 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_2" -> "584 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_8"; +"581 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_6" -> "582 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_2"; +"582 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_2" -> "585 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__4"; +"585 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__4" -> "587 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_2"; +"586 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "587 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_2"; +"587 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_2" -> "588 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_2"; +"588 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_2" -> "589 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[2]/__mul___0"; +"589 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[2]/__mul___0" -> "590 VFNet/VFNetHead[bbox_head]/float_5"; +"590 VFNet/VFNetHead[bbox_head]/float_5" -> "591 VFNet/VFNetHead[bbox_head]/exp_5"; +"591 VFNet/VFNetHead[bbox_head]/exp_5" -> "592 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_20"; +"592 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_20" -> "593 VFNet/VFNetHead[bbox_head]/__mul___5"; +"594 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_2" -> "595 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_6"; +"594 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_2" -> "597 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_7"; +"594 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_2" -> "598 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_8"; +"595 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_6" -> "596 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_2"; +"596 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_2" -> "599 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__5"; +"599 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__5" -> "601 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_2"; +"600 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "601 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_2"; +"602 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "603 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"603 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" -> "604 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"604 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "605 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3"; +"605 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" -> "606 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__3"; +"606 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__3" -> "607 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"607 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "609 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"608 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "609 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"609 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" -> "610 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"610 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "611 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3"; +"611 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" -> "612 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__3"; +"612 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__3" -> "613 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"613 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "615 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"614 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "615 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"615 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" -> "616 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"616 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "617 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3"; +"617 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" -> "618 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__3"; +"618 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__3" -> "685 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_3"; +"619 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "620 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3"; +"620 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_3" -> "621 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"621 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "622 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3"; +"622 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_3" -> "623 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__3"; +"623 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__3" -> "624 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"624 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "626 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"625 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "626 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3"; +"626 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_3" -> "627 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"627 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "628 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3"; +"628 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_3" -> "629 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__3"; +"629 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__3" -> "630 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"630 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "632 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"631 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "632 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3"; +"632 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_3" -> "633 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3"; +"633 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_3" -> "634 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3"; +"634 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_3" -> "635 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3"; +"635 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3" -> "637 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_6"; +"635 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__3" -> "671 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_3"; +"636 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "638 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_3"; +"637 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_6" -> "638 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_3"; +"638 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_3" -> "639 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_7"; +"639 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_7" -> "640 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_3"; +"640 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_3" -> "641 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__3"; +"641 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__3" -> "642 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3"; +"642 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_3" -> "644 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_3"; +"643 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "644 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_3"; +"644 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_3" -> "645 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_3"; +"645 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_3" -> "646 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[3]/__mul___0"; +"646 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[3]/__mul___0" -> "647 VFNet/VFNetHead[bbox_head]/float_6"; +"647 VFNet/VFNetHead[bbox_head]/float_6" -> "648 VFNet/VFNetHead[bbox_head]/exp_6"; +"648 VFNet/VFNetHead[bbox_head]/exp_6" -> "649 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_21"; +"649 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_21" -> "650 VFNet/VFNetHead[bbox_head]/__mul___6"; +"650 VFNet/VFNetHead[bbox_head]/__mul___6" -> "651 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_22"; +"650 VFNet/VFNetHead[bbox_head]/__mul___6" -> "662 VFNet/VFNetHead[bbox_head]/new_zeros_3"; +"651 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_22" -> "652 VFNet/VFNetHead[bbox_head]/__rmul___21"; +"652 VFNet/VFNetHead[bbox_head]/__rmul___21" -> "653 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_23"; +"653 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_23" -> "654 VFNet/VFNetHead[bbox_head]/__radd___3"; +"654 VFNet/VFNetHead[bbox_head]/__radd___3" -> "655 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_24"; +"655 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_24" -> "656 VFNet/VFNetHead[bbox_head]/__truediv___3"; +"656 VFNet/VFNetHead[bbox_head]/__truediv___3" -> "657 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_25"; +"657 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_25" -> "658 VFNet/VFNetHead[bbox_head]/__getitem___12"; +"657 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_25" -> "659 VFNet/VFNetHead[bbox_head]/__getitem___13"; +"657 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_25" -> "660 VFNet/VFNetHead[bbox_head]/__getitem___14"; +"657 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_25" -> "661 VFNet/VFNetHead[bbox_head]/__getitem___15"; +"658 VFNet/VFNetHead[bbox_head]/__getitem___12" -> "665 VFNet/VFNetHead[bbox_head]/__rmul___23"; +"658 VFNet/VFNetHead[bbox_head]/__getitem___12" -> "668 VFNet/VFNetHead[bbox_head]/__rmul___26"; +"658 VFNet/VFNetHead[bbox_head]/__getitem___12" -> "669 VFNet/VFNetHead[bbox_head]/__rmul___27"; +"659 VFNet/VFNetHead[bbox_head]/__getitem___13" -> "664 VFNet/VFNetHead[bbox_head]/__rmul___22"; +"659 VFNet/VFNetHead[bbox_head]/__getitem___13" -> "666 VFNet/VFNetHead[bbox_head]/__rmul___24"; +"659 VFNet/VFNetHead[bbox_head]/__getitem___13" -> "667 VFNet/VFNetHead[bbox_head]/__rmul___25"; +"662 VFNet/VFNetHead[bbox_head]/new_zeros_3" -> "663 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_26"; +"663 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_26" -> "670 VFNet/VFNetHead[bbox_head]/__sub___3"; +"670 VFNet/VFNetHead[bbox_head]/__sub___3" -> "671 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_3"; +"670 VFNet/VFNetHead[bbox_head]/__sub___3" -> "685 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_3"; +"671 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_3" -> "672 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_9"; +"671 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_3" -> "674 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_10"; +"671 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_3" -> "675 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_11"; +"672 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_9" -> "673 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_3"; +"673 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_3" -> "676 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__6"; +"676 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__6" -> "678 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_3"; +"677 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "678 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_3"; +"678 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_3" -> "679 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_3"; +"679 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_3" -> "680 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[3]/__mul___0"; +"680 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[3]/__mul___0" -> "681 VFNet/VFNetHead[bbox_head]/float_7"; +"681 VFNet/VFNetHead[bbox_head]/float_7" -> "682 VFNet/VFNetHead[bbox_head]/exp_7"; +"682 VFNet/VFNetHead[bbox_head]/exp_7" -> "683 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_27"; +"683 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_27" -> "684 VFNet/VFNetHead[bbox_head]/__mul___7"; +"685 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_3" -> "686 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_9"; +"685 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_3" -> "688 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_10"; +"685 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_3" -> "689 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_11"; +"686 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_9" -> "687 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_3"; +"687 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_3" -> "690 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__7"; +"690 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__7" -> "692 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_3"; +"691 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "692 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_3"; +"693 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "694 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"694 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" -> "695 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"695 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "696 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4"; +"696 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" -> "697 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__4"; +"697 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/relu__4" -> "698 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"698 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "700 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"699 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "700 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"700 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" -> "701 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"701 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "702 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4"; +"702 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" -> "703 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__4"; +"703 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/relu__4" -> "704 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"704 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "706 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"705 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "706 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"706 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" -> "707 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"707 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "708 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4"; +"708 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" -> "709 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__4"; +"709 VFNet/VFNetHead[bbox_head]/ModuleList[cls_convs]/ConvModule[2]/ReLU[activate]/relu__4" -> "776 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_4"; +"710 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "711 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4"; +"711 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_4" -> "712 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"712 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "713 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4"; +"713 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/NNCFGroupNorm[gn]/group_norm_4" -> "714 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__4"; +"714 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/relu__4" -> "715 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"715 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "717 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"716 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "717 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4"; +"717 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_4" -> "718 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"718 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "719 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4"; +"719 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/NNCFGroupNorm[gn]/group_norm_4" -> "720 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__4"; +"720 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/relu__4" -> "721 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"721 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "723 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"722 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "723 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4"; +"723 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_4" -> "724 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4"; +"724 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_4" -> "725 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4"; +"725 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/NNCFGroupNorm[gn]/group_norm_4" -> "726 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4"; +"726 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4" -> "728 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_8"; +"726 VFNet/VFNetHead[bbox_head]/ModuleList[reg_convs]/ConvModule[2]/ReLU[activate]/relu__4" -> "762 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_4"; +"727 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "729 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_4"; +"728 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_8" -> "729 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_4"; +"729 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/conv2d_4" -> "730 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_9"; +"730 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_9" -> "731 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_4"; +"731 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/NNCFGroupNorm[gn]/group_norm_4" -> "732 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__4"; +"732 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/relu__4" -> "733 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4"; +"733 VFNet/VFNetHead[bbox_head]/ConvModule[vfnet_reg_conv]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_4" -> "735 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_4"; +"734 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "735 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_4"; +"735 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/conv2d_4" -> "736 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_4"; +"736 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg]/SymmetricQuantizer/symmetric_quantize_4" -> "737 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[4]/__mul___0"; +"737 VFNet/VFNetHead[bbox_head]/ModuleList[scales]/Scale[4]/__mul___0" -> "738 VFNet/VFNetHead[bbox_head]/float_8"; +"738 VFNet/VFNetHead[bbox_head]/float_8" -> "739 VFNet/VFNetHead[bbox_head]/exp_8"; +"739 VFNet/VFNetHead[bbox_head]/exp_8" -> "740 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_28"; +"740 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_28" -> "741 VFNet/VFNetHead[bbox_head]/__mul___8"; +"741 VFNet/VFNetHead[bbox_head]/__mul___8" -> "742 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_29"; +"741 VFNet/VFNetHead[bbox_head]/__mul___8" -> "753 VFNet/VFNetHead[bbox_head]/new_zeros_4"; +"742 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_29" -> "743 VFNet/VFNetHead[bbox_head]/__rmul___28"; +"743 VFNet/VFNetHead[bbox_head]/__rmul___28" -> "744 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_30"; +"744 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_30" -> "745 VFNet/VFNetHead[bbox_head]/__radd___4"; +"745 VFNet/VFNetHead[bbox_head]/__radd___4" -> "746 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_31"; +"746 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_31" -> "747 VFNet/VFNetHead[bbox_head]/__truediv___4"; +"747 VFNet/VFNetHead[bbox_head]/__truediv___4" -> "748 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_32"; +"748 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_32" -> "749 VFNet/VFNetHead[bbox_head]/__getitem___16"; +"748 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_32" -> "750 VFNet/VFNetHead[bbox_head]/__getitem___17"; +"748 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_32" -> "751 VFNet/VFNetHead[bbox_head]/__getitem___18"; +"748 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_32" -> "752 VFNet/VFNetHead[bbox_head]/__getitem___19"; +"749 VFNet/VFNetHead[bbox_head]/__getitem___16" -> "756 VFNet/VFNetHead[bbox_head]/__rmul___30"; +"749 VFNet/VFNetHead[bbox_head]/__getitem___16" -> "759 VFNet/VFNetHead[bbox_head]/__rmul___33"; +"749 VFNet/VFNetHead[bbox_head]/__getitem___16" -> "760 VFNet/VFNetHead[bbox_head]/__rmul___34"; +"750 VFNet/VFNetHead[bbox_head]/__getitem___17" -> "755 VFNet/VFNetHead[bbox_head]/__rmul___29"; +"750 VFNet/VFNetHead[bbox_head]/__getitem___17" -> "757 VFNet/VFNetHead[bbox_head]/__rmul___31"; +"750 VFNet/VFNetHead[bbox_head]/__getitem___17" -> "758 VFNet/VFNetHead[bbox_head]/__rmul___32"; +"753 VFNet/VFNetHead[bbox_head]/new_zeros_4" -> "754 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_33"; +"754 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_33" -> "761 VFNet/VFNetHead[bbox_head]/__sub___4"; +"761 VFNet/VFNetHead[bbox_head]/__sub___4" -> "762 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_4"; +"761 VFNet/VFNetHead[bbox_head]/__sub___4" -> "776 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_4"; +"762 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_4" -> "763 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_12"; +"762 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_4" -> "765 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_13"; +"762 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/type_as_4" -> "766 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_14"; +"763 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/new_empty_12" -> "764 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_4"; +"764 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_reg_refine_dconv]/SymmetricQuantizer/symmetric_quantize_4" -> "767 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__8"; +"767 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__8" -> "769 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_4"; +"768 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "769 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_4"; +"769 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/conv2d_4" -> "770 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_4"; +"770 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_reg_refine]/SymmetricQuantizer/symmetric_quantize_4" -> "771 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[4]/__mul___0"; +"771 VFNet/VFNetHead[bbox_head]/ModuleList[scales_refine]/Scale[4]/__mul___0" -> "772 VFNet/VFNetHead[bbox_head]/float_9"; +"772 VFNet/VFNetHead[bbox_head]/float_9" -> "773 VFNet/VFNetHead[bbox_head]/exp_9"; +"773 VFNet/VFNetHead[bbox_head]/exp_9" -> "774 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_34"; +"774 VFNet/VFNetHead[bbox_head]/SymmetricQuantizer/symmetric_quantize_34" -> "775 VFNet/VFNetHead[bbox_head]/__mul___9"; +"776 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_4" -> "777 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_12"; +"776 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_4" -> "779 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_13"; +"776 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/type_as_4" -> "780 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_14"; +"777 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/new_empty_12" -> "778 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_4"; +"778 VFNet/VFNetHead[bbox_head]/DeformConv2d[vfnet_cls_dconv]/SymmetricQuantizer/symmetric_quantize_4" -> "781 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__9"; +"781 VFNet/VFNetHead[bbox_head]/ReLU[relu]/relu__9" -> "783 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_4"; +"782 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "783 VFNet/VFNetHead[bbox_head]/NNCFConv2d[vfnet_cls]/conv2d_4"; +} diff --git a/external/mmdetection/tests/test_ote_api.py b/external/mmdetection/tests/test_ote_api.py new file mode 100644 index 00000000000..ef3f0827a5f --- /dev/null +++ b/external/mmdetection/tests/test_ote_api.py @@ -0,0 +1,554 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import glob +import io +import os.path as osp +import random +import time +import unittest +import warnings +from concurrent.futures import ThreadPoolExecutor +from subprocess import run # nosec +from typing import Optional + +import numpy as np +import torch +from bson import ObjectId +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_api +from ote_sdk.configuration.helper import convert, create +from ote_sdk.entities.annotation import AnnotationSceneEntity, AnnotationSceneKind +from ote_sdk.entities.dataset_item import DatasetItemEntity +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.image import Image +from ote_sdk.entities.inference_parameters import InferenceParameters +from ote_sdk.entities.model_template import TaskType, task_type_to_label_domain +from ote_sdk.entities.metrics import Performance +from ote_sdk.entities.model import ModelEntity, ModelFormat, ModelOptimizationType +from ote_sdk.entities.model_template import parse_model_template +from ote_sdk.entities.optimization_parameters import OptimizationParameters +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.entities.subset import Subset +from ote_sdk.entities.task_environment import TaskEnvironment +from ote_sdk.entities.train_parameters import TrainParameters +from ote_sdk.tests.test_helpers import generate_random_annotated_image +from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType, IExportTask +from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType +from ote_sdk.utils.shape_factory import ShapeFactory + +from detection_tasks.apis.detection import (OpenVINODetectionTask, OTEDetectionConfig, + OTEDetectionInferenceTask, + OTEDetectionNNCFTask, OTEDetectionTrainingTask) +from detection_tasks.apis.detection.ote_utils import generate_label_schema +from mmdet.integration.nncf.utils import is_nncf_enabled + +DEFAULT_TEMPLATE_DIR = osp.join('configs', 'custom-object-detection', 'gen3_mobilenetV2_ATSS') + +class ModelTemplate(unittest.TestCase): + def check_capabilities(self, template): + self.assertTrue(template.computes_representations()) + self.assertFalse(template.computes_uncertainty_score()) + self.assertEqual(len(template.capabilities), 1) + + @e2e_pytest_api + def test_reading_gen3_ssd(self): + template = parse_model_template(osp.join('configs', 'custom-object-detection', 'gen3_mobilenetV2_SSD', 'template.yaml')) + self.check_capabilities(template) + + @e2e_pytest_api + def test_reading_gen3_atss(self): + template = parse_model_template(osp.join('configs', 'custom-object-detection', 'gen3_mobilenetV2_ATSS', 'template.yaml')) + self.check_capabilities(template) + + @e2e_pytest_api + def test_reading_gen3_vfnet(self): + template = parse_model_template(osp.join('configs', 'custom-object-detection', 'gen3_resnet50_VFNet', 'template_experimental.yaml')) + self.check_capabilities(template) + + @e2e_pytest_api + def test_reading_yolox(self): + template = parse_model_template( + osp.join('configs', 'custom-object-detection', 'cspdarknet_YOLOX', + 'template.yaml')) + self.check_capabilities(template) + + +@e2e_pytest_api +def test_configuration_yaml(): + configuration = OTEDetectionConfig() + configuration_yaml_str = convert(configuration, str) + configuration_yaml_converted = create(configuration_yaml_str) + configuration_yaml_loaded = create(osp.join('detection_tasks', 'apis', 'detection', 'configuration.yaml')) + assert configuration_yaml_converted == configuration_yaml_loaded + + +class Sample(unittest.TestCase): + template = osp.join(DEFAULT_TEMPLATE_DIR, 'template.yaml') + + @e2e_pytest_api + def test_sample_on_cpu(self): + output = run('export CUDA_VISIBLE_DEVICES=;' + 'python detection_tasks/sample/sample.py ' + f'--export {self.template}', + shell=True, check=True) + assert output.returncode == 0 + + @e2e_pytest_api + def test_sample_on_gpu(self): + output = run('python detection_tasks/sample/sample.py ' + f'--export {self.template}', + shell=True, check=True) + assert output.returncode == 0 + + +class API(unittest.TestCase): + """ + Collection of tests for OTE API and OTE Model Templates + """ + + def init_environment( + self, + params, + model_template, + number_of_images=500, + task_type=TaskType.DETECTION): + + labels_names = ('rectangle', 'ellipse', 'triangle') + labels_schema = generate_label_schema(labels_names, task_type_to_label_domain(task_type)) + labels_list = labels_schema.get_labels(False) + environment = TaskEnvironment(model=None, hyper_parameters=params, label_schema=labels_schema, + model_template=model_template) + + warnings.filterwarnings('ignore', message='.* coordinates .* are out of bounds.*') + items = [] + for i in range(0, number_of_images): + image_numpy, annos = generate_random_annotated_image( + image_width=640, + image_height=480, + labels=labels_list, + max_shapes=20, + min_size=50, + max_size=100, + random_seed=None) + # Convert shapes according to task + for anno in annos: + if task_type == TaskType.INSTANCE_SEGMENTATION: + anno.shape = ShapeFactory.shape_as_polygon(anno.shape) + else: + anno.shape = ShapeFactory.shape_as_rectangle(anno.shape) + + image = Image(data=image_numpy) + annotation_scene = AnnotationSceneEntity( + kind=AnnotationSceneKind.ANNOTATION, + annotations=annos) + items.append(DatasetItemEntity(media=image, annotation_scene=annotation_scene)) + warnings.resetwarnings() + + rng = random.Random() + rng.shuffle(items) + for i, _ in enumerate(items): + subset_region = i / number_of_images + if subset_region >= 0.8: + subset = Subset.TESTING + elif subset_region >= 0.6: + subset = Subset.VALIDATION + else: + subset = Subset.TRAINING + items[i].subset = subset + + dataset = DatasetEntity(items) + return environment, dataset + + def setup_configurable_parameters(self, template_dir, num_iters=10): + glb = glob.glob(f'{template_dir}/template*.yaml') + template_path = glb[0] if glb else None + if not template_path: + raise RuntimeError(f"Template YAML not found: {template_dir}") + + model_template = parse_model_template(template_path) + hyper_parameters = create(model_template.hyper_parameters.data) + hyper_parameters.learning_parameters.num_iters = num_iters + hyper_parameters.postprocessing.result_based_confidence_threshold = False + hyper_parameters.postprocessing.confidence_threshold = 0.1 + return hyper_parameters, model_template + + @e2e_pytest_api + def test_cancel_training_detection(self): + """ + Tests starting and cancelling training. + + Flow of the test: + - Creates a randomly annotated project with a small dataset containing 3 classes: + ['rectangle', 'triangle', 'circle']. + - Start training and give cancel training signal after 10 seconds. Assert that training + stops within 35 seconds after that + - Start training and give cancel signal immediately. Assert that training stops within 25 seconds. + + This test should be finished in under one minute on a workstation. + """ + hyper_parameters, model_template = self.setup_configurable_parameters(DEFAULT_TEMPLATE_DIR, num_iters=500) + detection_environment, dataset = self.init_environment(hyper_parameters, model_template, 64) + + detection_task = OTEDetectionTrainingTask(task_environment=detection_environment) + + executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix='train_thread') + + output_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + + training_progress_curve = [] + def progress_callback(progress: float, score: Optional[float] = None): + training_progress_curve.append(progress) + + train_parameters = TrainParameters + train_parameters.update_progress = progress_callback + + # Test stopping after some time + start_time = time.time() + train_future = executor.submit(detection_task.train, dataset, output_model, train_parameters) + # give train_thread some time to initialize the model + while not detection_task._is_training: + time.sleep(10) + detection_task.cancel_training() + + # stopping process has to happen in less than 35 seconds + train_future.result() + self.assertEqual(training_progress_curve[-1], 100) + self.assertLess(time.time() - start_time, 100, 'Expected to stop within 100 seconds.') + + # Test stopping immediately (as soon as training is started). + start_time = time.time() + train_future = executor.submit(detection_task.train, dataset, output_model) + while not detection_task._is_training: + time.sleep(0.1) + detection_task.cancel_training() + + train_future.result() + self.assertLess(time.time() - start_time, 25) # stopping process has to happen in less than 25 seconds + + @e2e_pytest_api + def test_training_progress_tracking(self): + hyper_parameters, model_template = self.setup_configurable_parameters(DEFAULT_TEMPLATE_DIR, num_iters=5) + detection_environment, dataset = self.init_environment(hyper_parameters, model_template, 50) + + task = OTEDetectionTrainingTask(task_environment=detection_environment) + self.addCleanup(task._delete_scratch_space) + + print('Task initialized, model training starts.') + training_progress_curve = [] + + def progress_callback(progress: float, score: Optional[float] = None): + training_progress_curve.append(progress) + + train_parameters = TrainParameters + train_parameters.update_progress = progress_callback + output_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + task.train(dataset, output_model, train_parameters) + + self.assertGreater(len(training_progress_curve), 0) + training_progress_curve = np.asarray(training_progress_curve) + self.assertTrue(np.all(training_progress_curve[1:] >= training_progress_curve[:-1])) + + @e2e_pytest_api + def test_nncf_optimize_progress_tracking(self): + if not is_nncf_enabled(): + self.skipTest("Required NNCF module.") + + # Prepare pretrained weights + hyper_parameters, model_template = self.setup_configurable_parameters(DEFAULT_TEMPLATE_DIR, num_iters=2) + detection_environment, dataset = self.init_environment(hyper_parameters, model_template, 50) + + task = OTEDetectionTrainingTask(task_environment=detection_environment) + self.addCleanup(task._delete_scratch_space) + + original_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + task.train(dataset, original_model, TrainParameters) + + # Create NNCFTask + detection_environment.model = original_model + nncf_task = OTEDetectionNNCFTask(task_environment=detection_environment) + self.addCleanup(nncf_task._delete_scratch_space) + + # Rewrite some parameters to spend less time + nncf_task._config["runner"]["max_epochs"] = 10 + nncf_init_cfg = nncf_task._config["nncf_config"]["compression"][0]["initializer"] + nncf_init_cfg["range"]["num_init_samples"] = 1 + nncf_init_cfg["batchnorm_adaptation"]["num_bn_adaptation_samples"] = 1 + + print('Task initialized, model optimization starts.') + training_progress_curve = [] + + def progress_callback(progress: int): + assert isinstance(progress, int) + training_progress_curve.append(progress) + + optimization_parameters = OptimizationParameters + optimization_parameters.update_progress = progress_callback + nncf_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + + nncf_task.optimize(OptimizationType.NNCF, dataset, nncf_model, optimization_parameters) + + self.assertGreater(len(training_progress_curve), 0) + training_progress_curve = np.asarray(training_progress_curve) + self.assertTrue(np.all(training_progress_curve[1:] >= training_progress_curve[:-1])) + + @e2e_pytest_api + def test_inference_progress_tracking(self): + hyper_parameters, model_template = self.setup_configurable_parameters(DEFAULT_TEMPLATE_DIR, num_iters=10) + detection_environment, dataset = self.init_environment(hyper_parameters, model_template, 50) + + task = OTEDetectionTrainingTask(task_environment=detection_environment) + self.addCleanup(task._delete_scratch_space) + + print('Task initialized, model inference starts.') + inference_progress_curve = [] + + def progress_callback(progress: int): + assert isinstance(progress, int) + inference_progress_curve.append(progress) + + inference_parameters = InferenceParameters + inference_parameters.update_progress = progress_callback + + task.infer(dataset.with_empty_annotations(), inference_parameters) + + self.assertGreater(len(inference_progress_curve), 0) + inference_progress_curve = np.asarray(inference_progress_curve) + self.assertTrue(np.all(inference_progress_curve[1:] >= inference_progress_curve[:-1])) + + @e2e_pytest_api + def test_inference_task(self): + # Prepare pretrained weights + hyper_parameters, model_template = self.setup_configurable_parameters(DEFAULT_TEMPLATE_DIR, num_iters=2) + detection_environment, dataset = self.init_environment(hyper_parameters, model_template, 50) + val_dataset = dataset.get_subset(Subset.VALIDATION) + + train_task = OTEDetectionTrainingTask(task_environment=detection_environment) + self.addCleanup(train_task._delete_scratch_space) + + trained_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + train_task.train(dataset, trained_model, TrainParameters) + performance_after_train = self.eval(train_task, trained_model, val_dataset) + + # Create InferenceTask + detection_environment.model = trained_model + inference_task = OTEDetectionInferenceTask(task_environment=detection_environment) + self.addCleanup(inference_task._delete_scratch_space) + + performance_after_load = self.eval(inference_task, trained_model, val_dataset) + + assert performance_after_train == performance_after_load + + # Export + exported_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + _id=ObjectId()) + inference_task.export(ExportType.OPENVINO, exported_model) + + @staticmethod + def eval(task: OTEDetectionTrainingTask, model: ModelEntity, dataset: DatasetEntity) -> Performance: + start_time = time.time() + result_dataset = task.infer(dataset.with_empty_annotations()) + end_time = time.time() + print(f'{len(dataset)} analysed in {end_time - start_time} seconds') + result_set = ResultSetEntity( + model=model, + ground_truth_dataset=dataset, + prediction_dataset=result_dataset + ) + task.evaluate(result_set) + assert result_set.performance is not None + return result_set.performance + + def check_threshold(self, reference, value, delta_tolerance, message=''): + delta = value.score.value - reference.score.value + self.assertLessEqual( + np.abs(delta), + delta_tolerance, + msg=message + + f' (reference metric: {reference.score.value}, ' + f'actual value: {value.score.value}, ' + f'delta tolerance threshold: {delta_tolerance})' + ) + + def end_to_end( + self, + template_dir, + num_iters=5, + quality_score_threshold=0.5, + reload_perf_delta_tolerance=0.0, + export_perf_delta_tolerance=0.0005, + pot_perf_delta_tolerance=0.1, + nncf_perf_delta_tolerance=0.1, + task_type=TaskType.DETECTION): + + hyper_parameters, model_template = self.setup_configurable_parameters( + template_dir, num_iters=num_iters) + detection_environment, dataset = self.init_environment( + hyper_parameters, model_template, 250, task_type=task_type) + + val_dataset = dataset.get_subset(Subset.VALIDATION) + task = OTEDetectionTrainingTask(task_environment=detection_environment) + self.addCleanup(task._delete_scratch_space) + + print('Task initialized, model training starts.') + # Train the task. + # train_task checks that the task returns an Model and that + # validation f-measure is higher than the threshold, which is a pretty low bar + # considering that the dataset is so easy + output_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + _id=ObjectId()) + task.train(dataset, output_model) + + # Test that output model is valid. + modelinfo = torch.load(io.BytesIO(output_model.get_data("weights.pth"))) + modelinfo.pop('anchors', None) + self.assertEqual(list(modelinfo.keys()), ['model', 'config', 'confidence_threshold', 'VERSION']) + + # Run inference. + validation_performance = self.eval(task, output_model, val_dataset) + print(f'Performance: {validation_performance.score.value:.4f}') + self.assertGreater(validation_performance.score.value, quality_score_threshold, + f'Expected F-measure to be higher than {quality_score_threshold}') + + # Run another training round. + first_model = output_model + new_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + _id=ObjectId()) + task._hyperparams.learning_parameters.num_iters = 1 + task.train(dataset, new_model) + self.assertNotEqual(first_model, new_model) + self.assertNotEqual(first_model.get_data("weights.pth"), new_model.get_data("weights.pth")) + + # Reload task with the first model. + detection_environment.model = first_model + task = OTEDetectionTrainingTask(detection_environment) + self.assertEqual(task._task_environment.model.id, first_model.id) + + print('Reevaluating model.') + # Performance should be the same after reloading + performance_after_reloading = self.eval(task, output_model, val_dataset) + print(f'Performance after reloading: {performance_after_reloading.score.value:.4f}') + self.check_threshold(validation_performance, performance_after_reloading, reload_perf_delta_tolerance, + 'Too big performance difference after model reload.') + + if isinstance(task, IExportTask): + # Run export. + exported_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + _id=ObjectId()) + task.export(ExportType.OPENVINO, exported_model) + self.assertEqual(exported_model.model_format, ModelFormat.OPENVINO) + self.assertEqual(exported_model.optimization_type, ModelOptimizationType.MO) + + # Create OpenVINO Task and evaluate the model. + detection_environment.model = exported_model + ov_task = OpenVINODetectionTask(detection_environment) + predicted_validation_dataset = ov_task.infer(val_dataset.with_empty_annotations()) + resultset = ResultSetEntity( + model=output_model, + ground_truth_dataset=val_dataset, + prediction_dataset=predicted_validation_dataset, + ) + ov_task.evaluate(resultset) + export_performance = resultset.performance + assert export_performance is not None + print(f'Performance of exported model: {export_performance.score.value:.4f}') + self.check_threshold(validation_performance, export_performance, export_perf_delta_tolerance, + 'Too big performance difference after OpenVINO export.') + + # Run POT optimization and evaluate the result. + print('Run POT optimization.') + optimized_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + ov_task.optimize(OptimizationType.POT, dataset, optimized_model, OptimizationParameters()) + pot_performance = self.eval(ov_task, optimized_model, val_dataset) + print(f'Performance of optimized model: {pot_performance.score.value:.4f}') + self.check_threshold(validation_performance, pot_performance, pot_perf_delta_tolerance, + 'Too big performance difference after POT optimization.') + + if model_template.entrypoints.nncf: + if is_nncf_enabled(): + print('Run NNCF optimization.') + nncf_model = ModelEntity( + dataset, + detection_environment.get_model_configuration(), + ) + nncf_model.set_data('weights.pth', output_model.get_data("weights.pth")) + + detection_environment.model = nncf_model + + nncf_task = OTEDetectionNNCFTask(task_environment=detection_environment) + + nncf_task.optimize(OptimizationType.NNCF, dataset, nncf_model, OptimizationParameters()) + nncf_task.save_model(nncf_model) + nncf_performance = self.eval(nncf_task, nncf_model, val_dataset) + + print(f'Performance of NNCF model: {nncf_performance.score.value:.4f}') + self.check_threshold(validation_performance, nncf_performance, nncf_perf_delta_tolerance, + 'Too big performance difference after NNCF optimization.') + else: + print('Skipped test of OTEDetectionNNCFTask. Required NNCF module.') + + @e2e_pytest_api + def test_training_gen3_ssd(self): + self.end_to_end(osp.join('configs', 'custom-object-detection', 'gen3_mobilenetV2_SSD')) + + @e2e_pytest_api + def test_training_gen3_atss(self): + self.end_to_end(osp.join('configs', 'custom-object-detection', 'gen3_mobilenetV2_ATSS')) + + @e2e_pytest_api + def test_training_gen3_vfnet(self): + self.end_to_end(osp.join('configs', 'custom-object-detection', 'gen3_resnet50_VFNet'), + export_perf_delta_tolerance=0.01) + + @e2e_pytest_api + def test_training_yolox(self): + self.end_to_end( + osp.join('configs', 'custom-object-detection', 'cspdarknet_YOLOX')) + + @e2e_pytest_api + def test_training_maskrcnn_resnet50(self): + self.end_to_end(osp.join('configs', + 'custom-counting-instance-seg', 'resnet50_maskrcnn'), + task_type=TaskType.INSTANCE_SEGMENTATION) + + @e2e_pytest_api + def test_training_maskrcnn_efficientnetb2b(self): + self.end_to_end(osp.join('configs', + 'custom-counting-instance-seg', 'efficientnetb2b_maskrcnn'), + task_type=TaskType.INSTANCE_SEGMENTATION) diff --git a/external/mmdetection/tests/test_ote_inference.py b/external/mmdetection/tests/test_ote_inference.py new file mode 100644 index 00000000000..40f00ea1374 --- /dev/null +++ b/external/mmdetection/tests/test_ote_inference.py @@ -0,0 +1,131 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import itertools +import unittest + +import json +import mmcv +import os +import os.path as osp +import torch +from mmcv.parallel import MMDataParallel +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_api +from subprocess import run # nosec + +from mmdet.apis import init_detector, single_gpu_test +from mmdet.datasets import build_dataloader, build_dataset +from mmdet.parallel import MMDataCPU + +MODEL_CONFIGS = [ + 'configs/custom-object-detection/gen3_resnet50_VFNet/model.py', + 'configs/custom-object-detection/gen3_mobilenetV2_ATSS/model.py', + 'configs/custom-object-detection/gen3_mobilenetV2_SSD/model.py', + 'configs/custom-object-detection/cspdarknet_YOLOX/model.py' +] + +DEVICES = ['cuda:0', 'cpu'] + + +class TestInference(unittest.TestCase): + root_dir = '/tmp' + coco_dir = osp.join(root_dir, 'data/coco') + + @staticmethod + def shorten_annotation(src_path, dst_path, num_images): + with open(src_path) as read_file: + content = json.load(read_file) + selected_indexes = sorted( + [item['id'] for item in content['images']]) + selected_indexes = selected_indexes[:num_images] + content['images'] = [ + item for item in content['images'] + if item['id'] in selected_indexes + ] + content['annotations'] = [ + item for item in content['annotations'] + if item['image_id'] in selected_indexes + ] + content['licenses'] = [ + item for item in content['licenses'] + if item['id'] in selected_indexes + ] + + with open(dst_path, 'w') as write_file: + json.dump(content, write_file) + + @classmethod + def setUpClass(cls): + cls.test_on_full = False + os.makedirs(cls.coco_dir, exist_ok=True) + if not osp.exists(osp.join(cls.coco_dir, 'val2017.zip')): + run(f'wget --no-verbose http://images.cocodataset.org/zips/val2017.zip -P {cls.coco_dir}', + check=True, + shell=True) + if not osp.exists(osp.join(cls.coco_dir, 'val2017')): + run(f'unzip {osp.join(cls.coco_dir, "val2017.zip")} -d {cls.coco_dir}', + check=True, + shell=True) + if not osp.exists( + osp.join(cls.coco_dir, "annotations_trainval2017.zip")): + run(f'wget --no-verbose http://images.cocodataset.org/annotations/annotations_trainval2017.zip -P {cls.coco_dir}', + check=True, + shell=True) + if not osp.exists( + osp.join(cls.coco_dir, 'annotations/instances_val2017.json')): + run(f'unzip -o {osp.join(cls.coco_dir, "annotations_trainval2017.zip")} -d {cls.coco_dir}', + check=True, + shell=True) + + if cls.test_on_full: + cls.shorten_to = 5000 + else: + cls.shorten_to = 10 + + cls.src_anno = osp.join(cls.coco_dir, + 'annotations/instances_val2017.json') + cls.dst_anno = osp.join( + cls.coco_dir, + f'annotations/instances_val2017_short_to_{cls.shorten_to}.json') + cls.shorten_annotation(cls.src_anno, cls.dst_anno, cls.shorten_to) + + @e2e_pytest_api + def test_inference(self): + for cfg, device in itertools.product(MODEL_CONFIGS, DEVICES): + print(f'Starting inference test: {cfg} on {device}') + self.run_test(cfg, device) + + def run_test(self, cfg_path, device): + config = mmcv.Config.fromfile(cfg_path) + config.data.test.ann_file = self.dst_anno + config.data.test.img_prefix = osp.join(self.coco_dir, 'val2017') + model = init_detector(config, config.load_from, device=device) + dataset = build_dataset(config.data.test) + data_loader = build_dataloader( + dataset, + samples_per_gpu=1, + workers_per_gpu=config.data.workers_per_gpu, + dist=False, + shuffle=False) + + if 'cuda' in device and torch.cuda.is_available(): + device_id = int(device.split(':')[-1]) + model = MMDataParallel( + model.cuda(device_id), device_ids=[device_id]) + else: + model = MMDataCPU(model) + model.to(device) + + results = single_gpu_test(model, data_loader) + dataset.evaluate(results) diff --git a/external/mmdetection/tests/test_ote_training.py b/external/mmdetection/tests/test_ote_training.py new file mode 100644 index 00000000000..60260e8aa34 --- /dev/null +++ b/external/mmdetection/tests/test_ote_training.py @@ -0,0 +1,295 @@ +# Copyright (C) 2021 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +import logging +import os +from collections import namedtuple +from copy import deepcopy +from pprint import pformat +from typing import Any, Callable, Dict, List, Optional, Type + +import pytest +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.label import Domain +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.subset import Subset + +from detection_tasks.extension.datasets.data_utils import load_dataset_items_coco_format + +from ote_sdk.test_suite.e2e_test_system import DataCollector, e2e_pytest_performance +from ote_sdk.test_suite.training_tests_common import (make_path_be_abs, + make_paths_be_abs, + KEEP_CONFIG_FIELD_VALUE, + REALLIFE_USECASE_CONSTANT, + ROOT_PATH_KEY) +from ote_sdk.test_suite.training_tests_helper import (OTETestHelper, + DefaultOTETestCreationParametersInterface, + OTETrainingTestInterface) + + +logger = logging.getLogger(__name__) + +def DATASET_PARAMETERS_FIELDS() -> List[str]: + return deepcopy(['annotations_train', + 'images_train_dir', + 'annotations_val', + 'images_val_dir', + 'annotations_test', + 'images_test_dir', + ]) + +DatasetParameters = namedtuple('DatasetParameters', DATASET_PARAMETERS_FIELDS()) + + +def _get_dataset_params_from_dataset_definitions(dataset_definitions, dataset_name): + if dataset_name not in dataset_definitions: + raise ValueError(f'dataset {dataset_name} is absent in dataset_definitions, ' + f'dataset_definitions.keys={list(dataset_definitions.keys())}') + cur_dataset_definition = dataset_definitions[dataset_name] + training_parameters_fields = {k: v for k, v in cur_dataset_definition.items() + if k in DATASET_PARAMETERS_FIELDS()} + make_paths_be_abs(training_parameters_fields, dataset_definitions[ROOT_PATH_KEY]) + + assert set(DATASET_PARAMETERS_FIELDS()) == set(training_parameters_fields.keys()), \ + f'ERROR: dataset definitions for name={dataset_name} does not contain all required fields' + assert all(training_parameters_fields.values()), \ + f'ERROR: dataset definitions for name={dataset_name} contains empty values for some required fields' + + params = DatasetParameters(**training_parameters_fields) + return params + + +def _create_object_detection_dataset_and_labels_schema(dataset_params): + logger.debug(f'Using for train annotation file {dataset_params.annotations_train}') + logger.debug(f'Using for val annotation file {dataset_params.annotations_val}') + labels_list = [] + items = load_dataset_items_coco_format( + ann_file_path=dataset_params.annotations_train, + data_root_dir=dataset_params.images_train_dir, + domain=Domain.DETECTION, + subset=Subset.TRAINING, + labels_list=labels_list) + items.extend(load_dataset_items_coco_format( + ann_file_path=dataset_params.annotations_val, + data_root_dir=dataset_params.images_val_dir, + domain=Domain.DETECTION, + subset=Subset.VALIDATION, + labels_list=labels_list)) + items.extend(load_dataset_items_coco_format( + ann_file_path=dataset_params.annotations_test, + data_root_dir=dataset_params.images_test_dir, + domain=Domain.DETECTION, + subset=Subset.TESTING, + labels_list=labels_list)) + dataset = DatasetEntity(items=items) + labels_schema = LabelSchemaEntity.from_labels(labels_list) + return dataset, labels_schema + + +class ObjectDetectionTrainingTestParameters(DefaultOTETestCreationParametersInterface): + + def test_bunches(self) -> List[Dict[str, Any]]: + test_bunches = [ + dict( + model_name=[ + 'Custom_Object_Detection_Gen3_ATSS', + 'Custom_Object_Detection_Gen3_SSD', + ], + dataset_name='dataset1_tiled_shortened_500_A', + usecase='precommit', + ), + dict( + model_name=[ + 'Custom_Object_Detection_Gen3_ATSS', + 'Custom_Object_Detection_Gen3_SSD', + ], + dataset_name=[ + 'bbcd', + 'weed-coco', + 'pcd', + 'aerial', + 'dice', + 'fish', + 'vitens', + 'diopsis', + ], + num_training_iters=KEEP_CONFIG_FIELD_VALUE, + batch_size=KEEP_CONFIG_FIELD_VALUE, + usecase=REALLIFE_USECASE_CONSTANT, + ), + + ] + return deepcopy(test_bunches) + + +def get_dummy_compressed_model(task): + """ + Return compressed model without initialization + """ + # pylint:disable=protected-access + from mmdet.integration.nncf import wrap_nncf_model + from mmdet.apis.fake_input import get_fake_input + + # Disable quantaizers initialization + for compression in task._config.nncf_config['compression']: + if compression["algorithm"] == "quantization": + compression["initializer"] = { + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 0 + } + } + + _, compressed_model = wrap_nncf_model(task._model, + task._config, + get_fake_input_func=get_fake_input) + return compressed_model + + +class TestOTEReallifeObjectDetection(OTETrainingTestInterface): + """ + The main class of running test in this file. + """ + PERFORMANCE_RESULTS = None # it is required for e2e system + helper = OTETestHelper(ObjectDetectionTrainingTestParameters()) + + @classmethod + def get_list_of_tests(cls, usecase: Optional[str] = None): + """ + This method should be a classmethod. It is called before fixture initialization, during + tests discovering. + """ + return cls.helper.get_list_of_tests(usecase) + + @pytest.fixture + def params_factories_for_test_actions_fx(self, current_test_parameters_fx, + dataset_definitions_fx, template_paths_fx, + ote_current_reference_dir_fx) -> Dict[str,Callable[[], Dict]]: + logger.debug('params_factories_for_test_actions_fx: begin') + + test_parameters = deepcopy(current_test_parameters_fx) + dataset_definitions = deepcopy(dataset_definitions_fx) + template_paths = deepcopy(template_paths_fx) + def _training_params_factory() -> Dict: + if dataset_definitions is None: + pytest.skip('The parameter "--dataset-definitions" is not set') + + model_name = test_parameters['model_name'] + dataset_name = test_parameters['dataset_name'] + num_training_iters = test_parameters['num_training_iters'] + batch_size = test_parameters['batch_size'] + + dataset_params = _get_dataset_params_from_dataset_definitions(dataset_definitions, dataset_name) + + if model_name not in template_paths: + raise ValueError(f'Model {model_name} is absent in template_paths, ' + f'template_paths.keys={list(template_paths.keys())}') + template_path = make_path_be_abs(template_paths[model_name], template_paths[ROOT_PATH_KEY]) + + logger.debug('training params factory: Before creating dataset and labels_schema') + dataset, labels_schema = _create_object_detection_dataset_and_labels_schema(dataset_params) + logger.debug('training params factory: After creating dataset and labels_schema') + + return { + 'dataset': dataset, + 'labels_schema': labels_schema, + 'template_path': template_path, + 'num_training_iters': num_training_iters, + 'batch_size': batch_size, + } + + def _nncf_graph_params_factory() -> Dict: + if dataset_definitions is None: + pytest.skip('The parameter "--dataset-definitions" is not set') + + model_name = test_parameters['model_name'] + dataset_name = test_parameters['dataset_name'] + + dataset_params = _get_dataset_params_from_dataset_definitions(dataset_definitions, dataset_name) + + if model_name not in template_paths: + raise ValueError(f'Model {model_name} is absent in template_paths, ' + f'template_paths.keys={list(template_paths.keys())}') + template_path = make_path_be_abs(template_paths[model_name], template_paths[ROOT_PATH_KEY]) + + logger.debug('training params factory: Before creating dataset and labels_schema') + dataset, labels_schema = _create_object_detection_dataset_and_labels_schema(dataset_params) + logger.debug('training params factory: After creating dataset and labels_schema') + + return { + 'dataset': dataset, + 'labels_schema': labels_schema, + 'template_path': template_path, + 'reference_dir': ote_current_reference_dir_fx, + 'fn_get_compressed_model': get_dummy_compressed_model, + } + + params_factories_for_test_actions = { + 'training': _training_params_factory, + 'nncf_graph': _nncf_graph_params_factory, + } + logger.debug('params_factories_for_test_actions_fx: end') + return params_factories_for_test_actions + + @pytest.fixture + def test_case_fx(self, current_test_parameters_fx, params_factories_for_test_actions_fx): + """ + This fixture returns the test case class OTEIntegrationTestCase that should be used for the current test. + Note that the cache from the test helper allows to store the instance of the class + between the tests. + If the main parameters used for this test are the same as the main parameters used for the previous test, + the instance of the test case class will be kept and re-used. It is helpful for tests that can + re-use the result of operations (model training, model optimization, etc) made for the previous tests, + if these operations are time-consuming. + If the main parameters used for this test differs w.r.t. the previous test, a new instance of + test case class will be created. + """ + test_case = type(self).helper.get_test_case(current_test_parameters_fx, + params_factories_for_test_actions_fx) + return test_case + + # TODO(lbeynens): move to common fixtures + @pytest.fixture + def data_collector_fx(self, request) -> DataCollector: + setup = deepcopy(request.node.callspec.params) + setup['environment_name'] = os.environ.get('TT_ENVIRONMENT_NAME', 'no-env') + setup['test_type'] = os.environ.get('TT_TEST_TYPE', 'no-test-type') # TODO: get from e2e test type + setup['scenario'] = 'api' # TODO(lbeynens): get from a fixture! + setup['test'] = request.node.name + setup['subject'] = 'custom-object-detection' + setup['project'] = 'ote' + if 'test_parameters' in setup: + assert isinstance(setup['test_parameters'], dict) + if 'dataset_name' not in setup: + setup['dataset_name'] = setup['test_parameters'].get('dataset_name') + if 'model_name' not in setup: + setup['model_name'] = setup['test_parameters'].get('model_name') + if 'test_stage' not in setup: + setup['test_stage'] = setup['test_parameters'].get('test_stage') + if 'usecase' not in setup: + setup['usecase'] = setup['test_parameters'].get('usecase') + logger.info(f'creating DataCollector: setup=\n{pformat(setup, width=140)}') + data_collector = DataCollector(name='TestOTEIntegration', + setup=setup) + with data_collector: + logger.info('data_collector is created') + yield data_collector + logger.info('data_collector is released') + + @e2e_pytest_performance + def test(self, + test_parameters, + test_case_fx, data_collector_fx, + cur_test_expected_metrics_callback_fx): + test_case_fx.run_stage(test_parameters['test_stage'], data_collector_fx, + cur_test_expected_metrics_callback_fx) diff --git a/ote_cli/ote_cli/datasets/instance_segmentation/dataset.py b/ote_cli/ote_cli/datasets/instance_segmentation/dataset.py index 5c852ae42a9..546061346cc 100644 --- a/ote_cli/ote_cli/datasets/instance_segmentation/dataset.py +++ b/ote_cli/ote_cli/datasets/instance_segmentation/dataset.py @@ -16,7 +16,7 @@ # See the License for the specific language governing permissions # and limitations under the License. -from mmdet.apis.ote.extension.datasets.data_utils import load_dataset_items_coco_format +from detection_tasks.extension.datasets.data_utils import load_dataset_items_coco_format from ote_sdk.entities.datasets import DatasetEntity from ote_sdk.entities.label import Domain from ote_sdk.entities.subset import Subset diff --git a/ote_cli/ote_cli/datasets/object_detection/dataset.py b/ote_cli/ote_cli/datasets/object_detection/dataset.py index 46b67ada650..765e4199fdc 100644 --- a/ote_cli/ote_cli/datasets/object_detection/dataset.py +++ b/ote_cli/ote_cli/datasets/object_detection/dataset.py @@ -16,7 +16,7 @@ # See the License for the specific language governing permissions # and limitations under the License. -from mmdet.apis.ote.extension.datasets.data_utils import load_dataset_items_coco_format +from detection_tasks.extension.datasets.data_utils import load_dataset_items_coco_format from ote_sdk.entities.datasets import DatasetEntity from ote_sdk.entities.label import Domain from ote_sdk.entities.subset import Subset diff --git a/ote_cli/ote_cli/datasets/rotated_detection/dataset.py b/ote_cli/ote_cli/datasets/rotated_detection/dataset.py index 7c9954284f8..7da00b092e6 100644 --- a/ote_cli/ote_cli/datasets/rotated_detection/dataset.py +++ b/ote_cli/ote_cli/datasets/rotated_detection/dataset.py @@ -16,7 +16,7 @@ # See the License for the specific language governing permissions # and limitations under the License. -from mmdet.apis.ote.extension.datasets.data_utils import load_dataset_items_coco_format +from detection_tasks.extension.datasets.data_utils import load_dataset_items_coco_format from ote_sdk.entities.datasets import DatasetEntity from ote_sdk.entities.label import Domain from ote_sdk.entities.subset import Subset diff --git a/ote_cli/ote_cli/registry/registry.py b/ote_cli/ote_cli/registry/registry.py index 1c7d63813e2..4c25be03434 100644 --- a/ote_cli/ote_cli/registry/registry.py +++ b/ote_cli/ote_cli/registry/registry.py @@ -29,7 +29,7 @@ class Registry: Class that implements a model templates registry. """ - def __init__(self, templates_dir=None, templates=None): + def __init__(self, templates_dir=None, templates=None, experimental=False): if templates is None: if templates_dir is None: templates_dir = os.getenv("TEMPLATES_DIR") @@ -40,6 +40,13 @@ def __init__(self, templates_dir=None, templates=None): template_filenames = glob.glob( os.path.join(templates_dir, "**", "template.yaml"), recursive=True ) + if experimental: + template_filenames.extend( + glob.glob( + os.path.join(templates_dir, "**", "template_experimental.yaml"), + recursive=True, + ) + ) template_filenames = [os.path.abspath(p) for p in template_filenames] self.templates = [] diff --git a/ote_cli/ote_cli/tools/find.py b/ote_cli/ote_cli/tools/find.py index 0e83fe94005..57ad6fa60fc 100644 --- a/ote_cli/ote_cli/tools/find.py +++ b/ote_cli/ote_cli/tools/find.py @@ -31,6 +31,7 @@ def parse_args(): "--root", help="A root dir where templates should be searched.", default="." ) parser.add_argument("--task_type") + parser.add_argument("--experimental", action="store_true") return parser.parse_args() @@ -42,7 +43,7 @@ def main(): args = parse_args() - registry = Registry(args.root) + registry = Registry(args.root, experimental=args.experimental) if args.task_type: registry = registry.filter(task_type=args.task_type) diff --git a/tests/ote_cli/misc/test_template_files.py b/tests/ote_cli/misc/test_template_files.py index 4484e3033fc..128b2bb5c43 100644 --- a/tests/ote_cli/misc/test_template_files.py +++ b/tests/ote_cli/misc/test_template_files.py @@ -21,7 +21,7 @@ from ote_cli.registry import Registry -templates = Registry('external').templates +templates = Registry('external', experimental=True).templates paths = [os.path.relpath(template.model_template_path) for template in templates] ids = [os.path.relpath(template.model_template_id) for template in templates]