From ff0c0704c0fff49e01ff780a8a5ed3d02f06f486 Mon Sep 17 00:00:00 2001 From: Aleksei Kashapov Date: Thu, 18 Apr 2024 11:16:54 +0200 Subject: [PATCH 01/12] [OpenVINO] Update reference for YOLOV8 after PR#2610 (#2638) ### Changes Increase INT8 metrics after [2610](https://github.com/openvinotoolkit/nncf/pull/2610) ### Reason for changes Two extra quantizers were removed -> int8 metrics improved ### Related tickets N/A ### Tests test job is run --- tests/cross_fw/examples/example_scope.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/cross_fw/examples/example_scope.json b/tests/cross_fw/examples/example_scope.json index edebf9a839e..9d834b920fd 100644 --- a/tests/cross_fw/examples/example_scope.json +++ b/tests/cross_fw/examples/example_scope.json @@ -40,8 +40,8 @@ "cpu": "Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz", "accuracy_metrics": { "fp32_mAP": 0.45252755065175254, - "int8_mAP": 0.4425154975267813, - "accuracy_drop": 0.01001205312497122 + "int8_mAP": 0.4561537594798616, + "accuracy_drop": -0.00362620882 }, "performance_metrics": { "fp32_fps": 170.69, From 48c67bdb7e744119dc31237a50c0fe9902629f03 Mon Sep 17 00:00:00 2001 From: Alexander Dokuchaev Date: Thu, 18 Apr 2024 18:09:36 +0300 Subject: [PATCH 02/12] Deterministic order of testcases (#2642) ### Changes Deterministic order of testcases ### Reason for changes Required for parallel tests by pytest-xdist --- tests/torch/models_hub_test/test_timm.py | 36 +- tests/torch/models_hub_test/timm_models.txt | 464 ++++++++++++++++++++ tests/torch/test_algo_common.py | 4 +- tests/torch/test_resume_from_checkpoint.py | 11 +- 4 files changed, 480 insertions(+), 35 deletions(-) create mode 100644 tests/torch/models_hub_test/timm_models.txt diff --git a/tests/torch/models_hub_test/test_timm.py b/tests/torch/models_hub_test/test_timm.py index b4146418f3e..be17f954af5 100644 --- a/tests/torch/models_hub_test/test_timm.py +++ b/tests/torch/models_hub_test/test_timm.py @@ -9,6 +9,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from pathlib import Path from typing import Tuple import pytest @@ -18,32 +19,11 @@ from tests.torch.models_hub_test.common import BaseTestModel from tests.torch.models_hub_test.common import ExampleType +from tests.torch.models_hub_test.common import ModelInfo +from tests.torch.models_hub_test.common import get_model_params +from tests.torch.models_hub_test.common import idfn - -def filter_timm(timm_list: list) -> list: - unique_models = set() - filtered_list = [] - ignore_set = { - "base", "mini", "small", "xxtiny", "xtiny", "tiny", "lite", "nano", "pico", "medium", "big", - "large", "xlarge", "xxlarge", "huge", "gigantic", "giant", "enormous", "xs", "xxs", "s", "m", "l", "xl" - } # fmt: skip - for name in timm_list: - # first: remove datasets - name_parts = name.split(".") - _name = "_".join(name.split(".")[:-1]) if len(name_parts) > 1 else name - # second: remove sizes - name_set = set([n for n in _name.split("_") if not n.isnumeric()]) - name_set = name_set.difference(ignore_set) - name_join = "_".join(name_set) - if name_join not in unique_models: - unique_models.add(name_join) - filtered_list.append(name) - return filtered_list - - -def get_all_models() -> list: - m_list = timm.list_pretrained() - return filter_timm(m_list) +MODEL_LIST_FILE = Path(__file__).parent / "timm_models.txt" class TestTimmModel(BaseTestModel): @@ -54,6 +34,6 @@ def load_model(self, model_name: str) -> Tuple[nn.Module, ExampleType]: example = (torch.randn(shape),) return m, example - @pytest.mark.parametrize("name", get_all_models()) - def test_nncf_wrap(self, name): - self.nncf_wrap(name) + @pytest.mark.parametrize("model_info", get_model_params(MODEL_LIST_FILE), ids=idfn) + def test_nncf_wrap(self, model_info: ModelInfo): + self.nncf_wrap(model_info.model_name) diff --git a/tests/torch/models_hub_test/timm_models.txt b/tests/torch/models_hub_test/timm_models.txt new file mode 100644 index 00000000000..073bd61a361 --- /dev/null +++ b/tests/torch/models_hub_test/timm_models.txt @@ -0,0 +1,464 @@ +bat_resnext26ts.ch_in1k +beit_base_patch16_224.in22k_ft_in22k +beitv2_base_patch16_224.in1k_ft_in1k +botnet26t_256.c1_in1k +caformer_b36.sail_in1k +caformer_m36.sail_in1k +caformer_s18.sail_in1k +caformer_s36.sail_in1k +cait_m36_384.fb_dist_in1k +cait_m48_448.fb_dist_in1k +cait_s24_224.fb_dist_in1k +cait_s36_384.fb_dist_in1k +cait_xs24_384.fb_dist_in1k +cait_xxs24_224.fb_dist_in1k +cait_xxs36_224.fb_dist_in1k +coat_lite_medium.in1k +coatnet_0_rw_224.sw_in1k +coatnet_bn_0_rw_224.sw_in1k +coatnet_rmlp_1_rw2_224.sw_in12k +coatnet_rmlp_1_rw_224.sw_in1k +coatnext_nano_rw_224.sw_in1k +convformer_b36.sail_in1k +convformer_m36.sail_in1k +convformer_s18.sail_in1k +convformer_s36.sail_in1k +convit_base.fb_in1k +convmixer_768_32.in1k +convmixer_1024_20_ks9_p14.in1k +convnext_atto.d2_in1k +convnext_atto_ols.a2_in1k +convnext_base.clip_laion2b +convnext_femto.d1_in1k +convnext_femto_ols.d1_in1k +convnext_large_mlp.clip_laion2b_augreg +convnext_nano_ols.d1h_in1k +convnext_tiny_hnf.a2h_in1k +convnextv2_atto.fcmae +convnextv2_base.fcmae +convnextv2_femto.fcmae +crossvit_9_240.in1k +crossvit_9_dagger_240.in1k +cs3darknet_focus_l.c2ns_in1k +cs3darknet_l.c2ns_in1k +cs3darknet_x.c2ns_in1k +cs3edgenet_x.c2_in1k +cs3se_edgenet_x.c2ns_in1k +cs3sedarknet_l.c2ns_in1k +cs3sedarknet_x.c2ns_in1k +cspdarknet53.ra_in1k +cspresnet50.ra_in1k +cspresnext50.ra_in1k +darknet53.c2ns_in1k +darknetaa53.c2ns_in1k +davit_base.msft_in1k +deit3_base_patch16_224.fb_in1k +deit3_huge_patch14_224.fb_in1k +deit_base_distilled_patch16_224.fb_in1k +deit_base_patch16_224.fb_in1k +densenet121.ra_in1k +densenet161.tv_in1k +densenet169.tv_in1k +densenet201.tv_in1k +densenetblur121d.ra_in1k +dla34.in1k +dla46_c.in1k +dla46x_c.in1k +dla60.in1k +dla60_res2net.in1k +dla60_res2next.in1k +dla60x.in1k +dla60x_c.in1k +dla102.in1k +dla102x2.in1k +dla102x.in1k +dla169.in1k +dm_nfnet_f0.dm_in1k +dm_nfnet_f1.dm_in1k +dm_nfnet_f2.dm_in1k +dm_nfnet_f3.dm_in1k +dm_nfnet_f4.dm_in1k +dm_nfnet_f5.dm_in1k +dm_nfnet_f6.dm_in1k +dpn68.mx_in1k +dpn68b.mx_in1k +dpn92.mx_in1k +dpn98.mx_in1k +dpn107.mx_in1k +dpn131.mx_in1k +eca_botnext26ts_256.c1_in1k +eca_halonext26ts.c1_in1k +eca_nfnet_l0.ra2_in1k +eca_nfnet_l1.ra2_in1k +eca_nfnet_l2.ra3_in1k +eca_resnet33ts.ra2_in1k +eca_resnext26ts.ch_in1k +ecaresnet26t.ra2_in1k +ecaresnet50d.miil_in1k +ecaresnet50d_pruned.miil_in1k +ecaresnet50t.a1_in1k +ecaresnet101d.miil_in1k +ecaresnet101d_pruned.miil_in1k +ecaresnet269d.ra2_in1k +ecaresnetlight.miil_in1k +edgenext_base.in21k_ft_in1k +edgenext_small_rw.sw_in1k +edgenext_x_small.in1k +edgenext_xx_small.in1k +efficientformer_l1.snap_dist_in1k +efficientformer_l3.snap_dist_in1k +efficientformer_l7.snap_dist_in1k +efficientformerv2_l.snap_dist_in1k +efficientformerv2_s0.snap_dist_in1k +efficientformerv2_s1.snap_dist_in1k +efficientformerv2_s2.snap_dist_in1k +efficientnet_b0.ra_in1k +efficientnet_b1.ft_in1k +efficientnet_b1_pruned.in1k +efficientnet_b2.ra_in1k +efficientnet_b2_pruned.in1k +efficientnet_b3.ra2_in1k +efficientnet_b3_pruned.in1k +efficientnet_b4.ra2_in1k +efficientnet_b5.sw_in12k +efficientnet_el.ra_in1k +efficientnet_el_pruned.in1k +efficientnet_em.ra2_in1k +efficientnet_es.ra_in1k +efficientnet_es_pruned.in1k +efficientnet_lite0.ra_in1k +efficientnetv2_rw_m.agc_in1k +efficientnetv2_rw_t.ra2_in1k +ese_vovnet19b_dw.ra_in1k +ese_vovnet39b.ra_in1k +eva02_base_patch14_224.mim_in22k +eva02_base_patch16_clip_224.merged2b +eva02_enormous_patch14_clip_224.laion2b +eva_giant_patch14_224.clip_ft_in1k +eva_giant_patch14_clip_224.laion400m +fbnetc_100.rmsp_in1k +fbnetv3_b.ra2_in1k +fbnetv3_d.ra2_in1k +fbnetv3_g.ra2_in1k +flexivit_base.300ep_in1k +focalnet_base_lrf.ms_in1k +focalnet_base_srf.ms_in1k +focalnet_huge_fl3.ms_in22k +focalnet_huge_fl4.ms_in22k +gc_efficientnetv2_rw_t.agc_in1k +gcresnet33ts.ra2_in1k +gcresnet50t.ra2_in1k +gcresnext26ts.ch_in1k +gcresnext50ts.ch_in1k +gcvit_base.in1k +gernet_l.idstcv_in1k +ghostnet_100.in1k +gmixer_24_224.ra3_in1k +gmlp_s16_224.ra3_in1k +halo2botnet50ts_256.a1h_in1k +halonet26t.a1h_in1k +halonet50ts.a1h_in1k +haloregnetz_b.ra3_in1k +hardcorenas_a.miil_green_in1k +hardcorenas_b.miil_green_in1k +hardcorenas_c.miil_green_in1k +hardcorenas_d.miil_green_in1k +hardcorenas_e.miil_green_in1k +hardcorenas_f.miil_green_in1k +hrnet_w18.ms_aug_in1k +hrnet_w18_small_v2.ms_in1k +hrnet_w18_ssld.paddle_in1k +hrnet_w30.ms_in1k +hrnet_w32.ms_in1k +hrnet_w40.ms_in1k +hrnet_w44.ms_in1k +hrnet_w48.ms_in1k +hrnet_w48_ssld.paddle_in1k +hrnet_w64.ms_in1k +inception_resnet_v2.tf_ens_adv_in1k +inception_v3.gluon_in1k +inception_v4.tf_in1k +lambda_resnet26rpt_256.c1_in1k +lambda_resnet26t.c1_in1k +lambda_resnet50ts.a1h_in1k +lamhalobotnet50ts_256.a1h_in1k +lcnet_050.ra2_in1k +legacy_senet154.in1k +legacy_seresnet18.in1k +legacy_seresnet34.in1k +legacy_seresnet50.in1k +legacy_seresnet101.in1k +legacy_seresnet152.in1k +legacy_seresnext26_32x4d.in1k +legacy_seresnext50_32x4d.in1k +legacy_seresnext101_32x4d.in1k +legacy_xception.tf_in1k +levit_128.fb_dist_in1k +levit_128s.fb_dist_in1k +levit_conv_128.fb_dist_in1k +levit_conv_128s.fb_dist_in1k +maxvit_base_tf_224.in1k +maxvit_nano_rw_256.sw_in1k +maxvit_rmlp_base_rw_224.sw_in12k +maxvit_rmlp_tiny_rw_256.sw_in1k +maxxvit_rmlp_nano_rw_256.sw_in1k +maxxvit_rmlp_small_rw_256.sw_in1k +maxxvitv2_nano_rw_256.sw_in1k +maxxvitv2_rmlp_base_rw_224.sw_in12k +mixer_b16_224.goog_in21k +mixer_l16_224.goog_in21k +mixnet_l.ft_in1k +mnasnet_100.rmsp_in1k +mobilenetv2_050.lamb_in1k +mobilenetv2_110d.ra_in1k +mobilenetv2_120d.ra_in1k +mobilenetv3_large_100.miil_in21k +mobilenetv3_rw.rmsp_in1k +mobilevit_s.cvnets_in1k +mobilevitv2_050.cvnets_in1k +mvitv2_base.fb_in1k +mvitv2_base_cls.fb_inw21k +nasnetalarge.tf_in1k +nest_base_jx.goog_in1k +nf_regnet_b1.ra2_in1k +nf_resnet50.ra2_in1k +nfnet_l0.ra2_in1k +pit_b_224.in1k +pit_b_distilled_224.in1k +pit_s_224.in1k +pit_s_distilled_224.in1k +pit_ti_224.in1k +pit_ti_distilled_224.in1k +pnasnet5large.tf_in1k +poolformer_m36.sail_in1k +poolformer_m48.sail_in1k +poolformer_s12.sail_in1k +poolformer_s24.sail_in1k +poolformer_s36.sail_in1k +poolformerv2_m36.sail_in1k +poolformerv2_m48.sail_in1k +poolformerv2_s12.sail_in1k +poolformerv2_s24.sail_in1k +poolformerv2_s36.sail_in1k +pvt_v2_b0.in1k +pvt_v2_b1.in1k +pvt_v2_b2.in1k +pvt_v2_b2_li.in1k +pvt_v2_b3.in1k +pvt_v2_b4.in1k +pvt_v2_b5.in1k +regnetv_040.ra3_in1k +regnetx_002.pycls_in1k +regnetx_004_tv.tv2_in1k +regnety_002.pycls_in1k +regnety_008_tv.tv2_in1k +regnetz_040.ra3_in1k +regnetz_040_h.ra3_in1k +regnetz_b16.ra3_in1k +regnetz_c16.ra3_in1k +regnetz_c16_evos.ch_in1k +regnetz_d8.ra3_in1k +regnetz_d8_evos.ch_in1k +regnetz_d32.ra3_in1k +regnetz_e8.ra3_in1k +repvgg_a2.rvgg_in1k +repvgg_b0.rvgg_in1k +repvgg_b1.rvgg_in1k +repvgg_b1g4.rvgg_in1k +repvgg_b2.rvgg_in1k +repvgg_b2g4.rvgg_in1k +repvgg_b3.rvgg_in1k +repvgg_b3g4.rvgg_in1k +res2net50_14w_8s.in1k +res2net50_26w_4s.in1k +res2net50_26w_6s.in1k +res2net50_26w_8s.in1k +res2net50_48w_2s.in1k +res2net50d.in1k +res2net101_26w_4s.in1k +res2net101d.in1k +res2next50.in1k +resmlp_12_224.fb_dino +resnest14d.gluon_in1k +resnest26d.gluon_in1k +resnest50d.in1k +resnest50d_1s4x24d.in1k +resnest50d_4s2x40d.in1k +resnest101e.in1k +resnest200e.in1k +resnest269e.in1k +resnet10t.c3_in1k +resnet14t.c3_in1k +resnet18.a1_in1k +resnet18d.ra2_in1k +resnet26.bt_in1k +resnet26d.bt_in1k +resnet26t.ra2_in1k +resnet32ts.ra2_in1k +resnet33ts.ra2_in1k +resnet34.a1_in1k +resnet34d.ra2_in1k +resnet50.a1_in1k +resnet50_gn.a1h_in1k +resnet50c.gluon_in1k +resnet50d.a1_in1k +resnet50s.gluon_in1k +resnet51q.ra2_in1k +resnet61q.ra2_in1k +resnet101.a1_in1k +resnet101c.gluon_in1k +resnet101d.gluon_in1k +resnet101s.gluon_in1k +resnet152.a1_in1k +resnet152c.gluon_in1k +resnet152d.gluon_in1k +resnet152s.gluon_in1k +resnet200d.ra2_in1k +resnetaa50.a1h_in1k +resnetaa50d.d_in12k +resnetaa101d.sw_in12k +resnetblur50.bt_in1k +resnetrs50.tf_in1k +resnetrs101.tf_in1k +resnetrs152.tf_in1k +resnetrs200.tf_in1k +resnetrs270.tf_in1k +resnetrs350.tf_in1k +resnetrs420.tf_in1k +resnetv2_50.a1h_in1k +resnetv2_50d_evos.ah_in1k +resnetv2_50d_gn.ah_in1k +resnetv2_50x1_bit.goog_distilled_in1k +resnetv2_50x3_bit.goog_in21k +resnetv2_101x1_bit.goog_in21k +resnetv2_101x3_bit.goog_in21k +resnetv2_152x2_bit.goog_in21k +resnetv2_152x4_bit.goog_in21k +resnext26ts.ra2_in1k +resnext50_32x4d.a1_in1k +resnext50d_32x4d.bt_in1k +resnext101_32x4d.fb_ssl_yfcc100m_ft_in1k +resnext101_32x8d.fb_ssl_yfcc100m_ft_in1k +resnext101_32x16d.fb_ssl_yfcc100m_ft_in1k +resnext101_32x32d.fb_wsl_ig1b_ft_in1k +resnext101_64x4d.c1_in1k +rexnet_100.nav_in1k +rexnetr_200.sw_in12k +sebotnet33ts_256.a1h_in1k +sehalonet33ts.ra2_in1k +SelecSls42b.in1k +SelecSls60.in1k +SelecSls60b.in1k +semnasnet_075.rmsp_in1k +senet154.gluon_in1k +sequencer2d_l.in1k +seresnet33ts.ra2_in1k +seresnet50.a1_in1k +seresnet152d.ra2_in1k +seresnext26d_32x4d.bt_in1k +seresnext26t_32x4d.bt_in1k +seresnext26ts.ch_in1k +seresnext50_32x4d.gluon_in1k +seresnext101_32x4d.gluon_in1k +seresnext101_32x8d.ah_in1k +seresnext101_64x4d.gluon_in1k +seresnext101d_32x8d.ah_in1k +seresnextaa101d_32x8d.ah_in1k +skresnet18.ra_in1k +skresnet34.ra_in1k +skresnext50_32x4d.ra_in1k +spnasnet_100.rmsp_in1k +swin_base_patch4_window7_224.ms_in1k +swin_base_patch4_window12_384.ms_in1k +swin_s3_base_224.ms_in1k +swinv2_base_window8_256.ms_in1k +swinv2_base_window12_192.ms_in22k +swinv2_base_window12to16_192to256.ms_in22k_ft_in1k +swinv2_base_window12to24_192to384.ms_in22k_ft_in1k +swinv2_base_window16_256.ms_in1k +swinv2_cr_small_224.sw_in1k +swinv2_cr_small_ns_224.sw_in1k +tf_efficientnet_b0.aa_in1k +tf_efficientnet_b1.aa_in1k +tf_efficientnet_b2.aa_in1k +tf_efficientnet_b3.aa_in1k +tf_efficientnet_b4.aa_in1k +tf_efficientnet_b5.aa_in1k +tf_efficientnet_b6.aa_in1k +tf_efficientnet_b7.aa_in1k +tf_efficientnet_b8.ap_in1k +tf_efficientnet_cc_b0_4e.in1k +tf_efficientnet_cc_b0_8e.in1k +tf_efficientnet_cc_b1_8e.in1k +tf_efficientnet_el.in1k +tf_efficientnet_em.in1k +tf_efficientnet_es.in1k +tf_efficientnet_l2.ns_jft_in1k +tf_efficientnet_lite0.in1k +tf_efficientnet_lite1.in1k +tf_efficientnet_lite2.in1k +tf_efficientnet_lite3.in1k +tf_efficientnet_lite4.in1k +tf_efficientnetv2_b0.in1k +tf_efficientnetv2_b1.in1k +tf_efficientnetv2_b2.in1k +tf_efficientnetv2_b3.in1k +tf_efficientnetv2_l.in1k +tf_mixnet_l.in1k +tf_mobilenetv3_large_075.in1k +tf_mobilenetv3_large_minimal_100.in1k +tf_mobilenetv3_small_minimal_100.in1k +tinynet_a.in1k +tinynet_b.in1k +tinynet_c.in1k +tinynet_d.in1k +tinynet_e.in1k +tnt_s_patch16_224 +tresnet_l.miil_in1k +tresnet_v2_l.miil_in21k +twins_pcpvt_base.in1k +twins_svt_base.in1k +vgg11.tv_in1k +vgg11_bn.tv_in1k +vgg13.tv_in1k +vgg13_bn.tv_in1k +vgg16.tv_in1k +vgg16_bn.tv_in1k +vgg19.tv_in1k +vgg19_bn.tv_in1k +visformer_small.in1k +vit_base_patch8_224.augreg2_in21k_ft_in1k +vit_base_patch14_dinov2.lvd142m +vit_base_patch16_224.augreg2_in21k_ft_in1k +vit_base_patch16_224_miil.in21k +vit_base_patch16_clip_224.laion2b +vit_base_patch16_rpn_224.sw_in1k +vit_base_patch32_224.augreg_in1k +vit_base_patch32_clip_224.laion2b +vit_base_r50_s16_224.orig_in21k +vit_giant_patch14_clip_224.laion2b +vit_huge_patch14_224.mae +vit_large_r50_s32_224.augreg_in21k +vit_medium_patch16_gap_240.sw_in12k +vit_relpos_base_patch16_224.sw_in1k +vit_relpos_base_patch16_clsgap_224.sw_in1k +vit_relpos_base_patch32_plus_rpn_256.sw_in1k +vit_relpos_medium_patch16_cls_224.sw_in1k +vit_relpos_medium_patch16_rpn_224.sw_in1k +vit_small_r26_s32_224.augreg_in21k +vit_srelpos_medium_patch16_224.sw_in1k +vit_tiny_r_s16_p8_224.augreg_in21k +volo_d1_224.sail_in1k +volo_d2_224.sail_in1k +volo_d3_224.sail_in1k +volo_d4_224.sail_in1k +volo_d5_224.sail_in1k +wide_resnet50_2.racm_in1k +wide_resnet101_2.tv2_in1k +xception41.tf_in1k +xception41p.ra3_in1k +xception65.ra3_in1k +xception65p.ra3_in1k +xception71.tf_in1k +xcit_large_24_p8_224.fb_dist_in1k +xcit_large_24_p16_224.fb_dist_in1k diff --git a/tests/torch/test_algo_common.py b/tests/torch/test_algo_common.py index 8b7be3fc382..4b3172b8ea2 100644 --- a/tests/torch/test_algo_common.py +++ b/tests/torch/test_algo_common.py @@ -399,7 +399,7 @@ def test_compression_loss_gpu_device_compatibility(config): NOT_SUPPORT_SCOPES_ALGO = ["knowledge_distillation", "NoCompressionAlgorithm", "elasticity", "progressive_shrinking"] -@pytest.mark.parametrize("algo_name", PT_COMPRESSION_ALGORITHMS.registry_dict.keys() - NOT_SUPPORT_SCOPES_ALGO) +@pytest.mark.parametrize("algo_name", sorted(PT_COMPRESSION_ALGORITHMS.registry_dict.keys() - NOT_SUPPORT_SCOPES_ALGO)) @pytest.mark.parametrize("validate_scopes", (True, False, None)) def test_raise_validationerror_for_not_matched_scope_names(algo_name, validate_scopes): model = BasicLinearTestModel() @@ -450,7 +450,7 @@ def test_compressed_model_has_controller_references(algos: List[str]): ALGOS_SUPPORTING_SINGLE_LINE_CONFIGS = [ x - for x in PT_COMPRESSION_ALGORITHMS.registry_dict + for x in sorted(PT_COMPRESSION_ALGORITHMS.registry_dict.keys()) if x not in ["knowledge_distillation", "movement_sparsity", "elasticity", "progressive_shrinking"] ] diff --git a/tests/torch/test_resume_from_checkpoint.py b/tests/torch/test_resume_from_checkpoint.py index 82e4627c3bb..f35e199b076 100644 --- a/tests/torch/test_resume_from_checkpoint.py +++ b/tests/torch/test_resume_from_checkpoint.py @@ -117,7 +117,7 @@ def test_can_resume_with_algo_mixing(mocker, is_strict): SAVE_ALGOS += [[QUANTIZATION]] # Q SAVE_ALGOS += LOAD_ALGOS # Q , 3S, 3S + Q, Q+3S -ALGOS = list(itertools.product(SAVE_ALGOS, LOAD_ALGOS)) +ALGOS = list(sorted(itertools.product(SAVE_ALGOS, LOAD_ALGOS), key=lambda x: "_".join(x[0]) + "_".join(x[1]))) @pytest.fixture( @@ -153,7 +153,7 @@ def _algos(request): MODEL_WRAPPER = ["CPU", "GPU"] -WRAPPERS = list(itertools.product(MODEL_WRAPPER, MODEL_WRAPPER)) +WRAPPERS = list(sorted(itertools.product(MODEL_WRAPPER, MODEL_WRAPPER), key=lambda x: "_".join(x))) @pytest.fixture(scope="function", params=WRAPPERS, ids=["_".join(["from:" + w[0], "to:" + w[1]]) for w in WRAPPERS]) @@ -205,7 +205,9 @@ def test_load_state_interoperability(_algos, _model_wrapper, is_resume): RESUME_ALGOS += [[algo] for algo in SPARSITY_ALGOS] # 3S RESUME_ALGOS += [[QUANTIZATION]] # Q RESUME_ALGOS += [["EMPTY"]] # No Compression -RESUME_ALGOS = list(itertools.product(RESUME_ALGOS, RESUME_ALGOS)) +RESUME_ALGOS = list( + sorted(itertools.product(RESUME_ALGOS, RESUME_ALGOS), key=lambda x: "_".join(x[0]) + "_".join(x[1])) +) NUM_PARAMS_PER_ALGO = {QUANTIZATION: 8, "magnitude_sparsity": 1, "const_sparsity": 1, "rb_sparsity": 3, "EMPTY": 0} @@ -265,8 +267,7 @@ def test_load_state__with_resume_checkpoint(_resume_algos, _model_wrapper, mocke assert act_num_loaded == ref_num_loaded -LIST_ALGOS = [None, QUANTIZATION] -LIST_ALGOS += SPARSITY_ALGOS # 3S +LIST_ALGOS = sorted(["", QUANTIZATION] + list(SPARSITY_ALGOS)) @pytest.mark.parametrize("is_resume", (True, False), ids=["resume", "load_weights"]) From 96eef35e544bbddf4d02bd2fdd6342409f7af38c Mon Sep 17 00:00:00 2001 From: Aleksei Kashapov Date: Thu, 18 Apr 2024 17:56:15 +0200 Subject: [PATCH 03/12] [ONNX] Fix adding output nodes in NNCFGraph (#2538) ### Changes Do not add edges for the output node if it has no parents. E.g. output is put on the initializer. ### Reason for changes 125248 ### Related tickets 125248 ### Tests Checked on reproducer in the ticket --- nncf/onnx/graph/nncf_graph_builder.py | 50 ++++++++++--------- .../output_with_no_parents_model.dot | 7 +++ tests/onnx/test_nncf_graph_builder.py | 12 +++++ 3 files changed, 45 insertions(+), 24 deletions(-) create mode 100644 tests/onnx/data/reference_graphs/original_nncf_graph/synthetic/output_with_no_parents_model.dot diff --git a/nncf/onnx/graph/nncf_graph_builder.py b/nncf/onnx/graph/nncf_graph_builder.py index c5c6a3a3aa3..026f1600534 100644 --- a/nncf/onnx/graph/nncf_graph_builder.py +++ b/nncf/onnx/graph/nncf_graph_builder.py @@ -297,31 +297,33 @@ def _add_nncf_output_nodes( """ for i, _output in enumerate(model.graph.output): output_name = _output.name - layer_attributes = ONNXLayerAttributes() - output_node = nncf_graph.add_nncf_node( - node_name=MODEL_OUTPUT_OP_NAME + "_" + str(i), - node_type=NNCFGraphNodeType.OUTPUT_NODE, - node_metatype=OutputNoopMetatype, - layer_attributes=layer_attributes, - ) - from_node = parents_node_mapping[output_name] + if output_name in parents_node_mapping: + layer_attributes = ONNXLayerAttributes() + output_node = nncf_graph.add_nncf_node( + node_name=MODEL_OUTPUT_OP_NAME + "_" + str(i), + node_type=NNCFGraphNodeType.OUTPUT_NODE, + node_metatype=OutputNoopMetatype, + layer_attributes=layer_attributes, + ) - output_node_node_id = output_node.node_id - edge = edge_info_mapping[output_name] - output_shape = get_edge_shape(edge) - onnx_dtype = get_edge_dtype(edge) - nncf_dtype = GraphConverter.convert_onnx_dtype_to_nncf_dtype(onnx_dtype) - input_port_id = 0 - from_node_id = nncf_graph.get_node_by_name(from_node.name).node_id - output_port_id = get_output_port_id_for_node_before_output(output_name, from_node) - nncf_graph.add_edge_between_nncf_nodes( - from_node_id=from_node_id, - to_node_id=output_node_node_id, - tensor_shape=output_shape, - input_port_id=input_port_id, - output_port_id=output_port_id, - dtype=nncf_dtype, - ) + from_node = parents_node_mapping[output_name] + + output_node_node_id = output_node.node_id + edge = edge_info_mapping[output_name] + output_shape = get_edge_shape(edge) + onnx_dtype = get_edge_dtype(edge) + nncf_dtype = GraphConverter.convert_onnx_dtype_to_nncf_dtype(onnx_dtype) + input_port_id = 0 + from_node_id = nncf_graph.get_node_by_name(from_node.name).node_id + output_port_id = get_output_port_id_for_node_before_output(output_name, from_node) + nncf_graph.add_edge_between_nncf_nodes( + from_node_id=from_node_id, + to_node_id=output_node_node_id, + tensor_shape=output_shape, + input_port_id=input_port_id, + output_port_id=output_port_id, + dtype=nncf_dtype, + ) @staticmethod def convert_onnx_dtype_to_nncf_dtype(onnx_dtype: int) -> Dtype: diff --git a/tests/onnx/data/reference_graphs/original_nncf_graph/synthetic/output_with_no_parents_model.dot b/tests/onnx/data/reference_graphs/original_nncf_graph/synthetic/output_with_no_parents_model.dot new file mode 100644 index 00000000000..ef27eb6e149 --- /dev/null +++ b/tests/onnx/data/reference_graphs/original_nncf_graph/synthetic/output_with_no_parents_model.dot @@ -0,0 +1,7 @@ +strict digraph { +"0 Conv1" [id=0, type=Conv]; +"1 nncf_model_input_0" [id=1, type=nncf_model_input]; +"2 nncf_model_output_0" [id=2, type=nncf_model_output]; +"0 Conv1" -> "2 nncf_model_output_0" [label="[]", style=solid]; +"1 nncf_model_input_0" -> "0 Conv1" [label="[1, 3, 10, 10]", style=solid]; +} diff --git a/tests/onnx/test_nncf_graph_builder.py b/tests/onnx/test_nncf_graph_builder.py index 0797197c9c4..576aa55067c 100644 --- a/tests/onnx/test_nncf_graph_builder.py +++ b/tests/onnx/test_nncf_graph_builder.py @@ -16,9 +16,11 @@ import torch from torchvision import models +from nncf.onnx.graph.model_transformer import ONNXModelTransformer from nncf.onnx.graph.nncf_graph_builder import GraphConverter from tests.onnx.conftest import ONNX_TEST_ROOT from tests.onnx.models import ALL_SYNTHETIC_MODELS +from tests.onnx.models import OneConvolutionalModel from tests.onnx.opset_converter import convert_opset_version from tests.onnx.quantization.common import ModelToTest from tests.onnx.weightless_model import load_model_topology_with_zeros_weights @@ -99,3 +101,13 @@ def test_compare_nncf_graph_detection_real_models(tmp_path, model_to_test): nx_graph = nncf_graph.get_graph_for_structure_analysis(extended=True) compare_nx_graph_with_reference(nx_graph, path_to_dot, check_edge_attrs=True) + + +def test_add_output_nodes_with_no_parents_node(): + model_to_test = OneConvolutionalModel().onnx_model + model_outputs = (value_info.name for value_info in model_to_test.graph.output) + model_with_output = ONNXModelTransformer._insert_outputs(model_to_test, (*model_outputs, "Conv1_W")) + nncf_graph = GraphConverter.create_nncf_graph(model_with_output) + nx_graph = nncf_graph.get_graph_for_structure_analysis(extended=True) + path_to_dot = REFERENCE_GRAPHS_DIR / "synthetic" / "output_with_no_parents_model.dot" + compare_nx_graph_with_reference(nx_graph, path_to_dot, check_edge_attrs=True) From df81f44545cad470bccd9f3d30f2199a1d002285 Mon Sep 17 00:00:00 2001 From: Nikita Savelyev Date: Fri, 19 Apr 2024 11:32:34 +0200 Subject: [PATCH 04/12] [WC] Align compression subgraphs for both weight input data types (#2537) ### Changes Precision configuration of input OV model for weight compression can be one of the following three: 1. Weights and activations are in FP32 precision (model is saved with `compress_to_fp16=False`) 2. Weights are in FP16 and activations are in FP32 (model is saved with `compress_to_fp16=True`) 3. Weight and activations are in FP16 (e.g., PT model is first halfed and then converted to OV) This PR make compression subgraphs equal for all these three cases. Compression activations are always executed in FP16. So for the first case an additional f16 -> f32 Convert node is added. ![image](https://github.com/openvinotoolkit/nncf/assets/23343961/f301b7de-0599-4935-bcbb-0d28a67d8280) --- .../weight_compression/openvino_backend.py | 21 ++++--- tests/openvino/native/models.py | 11 ++-- .../quantization/test_weights_compression.py | 57 ++++++++++++------- 3 files changed, 56 insertions(+), 33 deletions(-) diff --git a/nncf/quantization/algorithms/weight_compression/openvino_backend.py b/nncf/quantization/algorithms/weight_compression/openvino_backend.py index f4d99638f62..5a5649a7d45 100644 --- a/nncf/quantization/algorithms/weight_compression/openvino_backend.py +++ b/nncf/quantization/algorithms/weight_compression/openvino_backend.py @@ -142,7 +142,7 @@ def transform_model( const_attributes = wc_params.node_with_weight.layer_attributes.constant_attributes[wc_params.weight_port_id] const_node_name = const_attributes["name"] const_node = self.name_to_node_mapping[const_node_name] - const_dtype = const_node.output(0).get_element_type().to_dtype() + const_dtype = const_node.output(0).get_element_type() weight = Tensor(get_const_value(const_node)) original_shape = weight.shape @@ -151,19 +151,21 @@ def transform_model( compressed_const = opset.constant( compressed_weight.tensor.data, dtype=compression_dtype, name=const_node_name ) - converted_const = opset.convert(compressed_const, const_dtype) + converted_const = opset.convert(compressed_const, ov.Type.f16) if compressed_weight.zero_point is not None: zero_point_const = opset.constant( compressed_weight.zero_point.data, dtype=compression_dtype, name=f"{const_node_name}/zero_point", ) - converted_zero_point = opset.convert(zero_point_const, const_dtype) - converted_const = opset.subtract(converted_const, converted_zero_point) + converted_zero_point = opset.convert(zero_point_const, ov.Type.f16) + converted_const = opset.subtract( + converted_const, converted_zero_point, name=f"{const_node_name}/zero_point/subtract" + ) - scale_const = opset.constant(compressed_weight.scale.data, dtype="float16", name=f"{const_node_name}/scale") - if const_dtype != "float16": - scale_const = opset.convert(scale_const, const_dtype, name=f"{const_node_name}/scale_convert") + scale_const = opset.constant( + compressed_weight.scale.data, dtype=ov.Type.f16, name=f"{const_node_name}/scale" + ) mul = opset.multiply( converted_const, scale_const, @@ -173,6 +175,11 @@ def transform_model( if compression_config.group_size != -1: mul = opset.reshape(mul, output_shape=original_shape, special_zero=False) + if const_dtype != ov.Type.f16: + mul = opset.convert( + mul, const_dtype, name=f"{const_node_name}/fq_weights_{wc_params.weight_port_id}/convert" + ) + mul_output = mul.output(0) for target_input in const_node.output(0).get_target_inputs(): target_input.replace_source_output(mul_output) diff --git a/tests/openvino/native/models.py b/tests/openvino/native/models.py index c25df4d862f..2b83a95457a 100644 --- a/tests/openvino/native/models.py +++ b/tests/openvino/native/models.py @@ -790,16 +790,19 @@ def _create_ov_model(self): class IdentityMatmul(OVReferenceModel): - def _create_ov_model(self, weights_dtype=None): + def _create_ov_model(self, weights_dtype=None, activation_dtype=None): """ :param: weights_dtype: precision of weights, should be either np.float32 or np.float16 + :param: activation_dtype: precision of activations, should be either np.float32 or np.float16 """ weights_dtype = np.float32 if weights_dtype is None else weights_dtype - input_node = opset.parameter([3, 3], name="Input_1") + activation_dtype = np.float32 if activation_dtype is None else activation_dtype + + input_node = opset.parameter([3, 3], dtype=activation_dtype, name="Input_1") weights_data = np.eye(3) * 255 current_weights = opset.constant(weights_data, dtype=weights_dtype, name="weights") - if weights_dtype != np.float32: - current_weights = opset.convert(current_weights, np.float32, name="weights/convert") + if weights_dtype != activation_dtype: + current_weights = opset.convert(current_weights, activation_dtype, name="weights/convert") matmul_node = opset.matmul(input_node, current_weights, transpose_a=False, transpose_b=True, name="MatMul") result = opset.result(matmul_node, name="Result") result.get_output_tensor(0).set_names(set(["Result"])) diff --git a/tests/openvino/native/quantization/test_weights_compression.py b/tests/openvino/native/quantization/test_weights_compression.py index 71556ce3ac6..f339d316d0d 100644 --- a/tests/openvino/native/quantization/test_weights_compression.py +++ b/tests/openvino/native/quantization/test_weights_compression.py @@ -96,8 +96,6 @@ def check_int8_node(op: ov.Node, mode: CompressWeightsMode = CompressWeightsMode mul_node = get_next_node(sub_node) assert mul_node.get_type_name() == "Multiply" scale_node = mul_node.input_value(1).get_node() - if scale_node.get_type_name() == "Convert": - scale_node = scale_node.input_value(0).get_node() scale = get_const_value(scale_node) return { @@ -134,13 +132,14 @@ def check_int4_grouped(op: ov.Node, mode: CompressWeightsMode, group_size: int = mul_node = get_next_node(sub_node) assert mul_node.get_type_name() == "Multiply" scale_node = mul_node.input_value(1).get_node() - if scale_node.get_type_name() == "Convert": - scale_node = scale_node.input_value(0).get_node() assert list(scale_node.shape) == reduced_weight_shape reshape_node = get_next_node(mul_node) assert reshape_node.get_type_name() == "Reshape" + convert_node = get_next_node(reshape_node) + assert convert_node.get_type_name() == "Convert" + return { "scale": get_const_value(scale_node), } @@ -160,13 +159,14 @@ def check_nf4_grouped(op: ov.Node, group_size: int = 7): mul_node = get_next_node(convert_node) assert mul_node.get_type_name() == "Multiply" scale_node = mul_node.input_value(1).get_node() - if scale_node.get_type_name() == "Convert": - scale_node = scale_node.input_value(0).get_node() assert list(scale_node.shape) == reduced_weight_shape reshape_node = get_next_node(mul_node) assert reshape_node.get_type_name() == "Reshape" + convert_node = get_next_node(reshape_node) + assert convert_node.get_type_name() == "Convert" + return { "scale": get_const_value(scale_node), } @@ -697,22 +697,35 @@ def test_data_type_for_num_weights(mocker): assert isinstance(params.num_weights, np.uint64) -def test_weight_scale_datatype(): - # When model weight is in fp32, there will be an extra convert node for weight scale f16 > f32 - model_fp32 = IdentityMatmul(weights_dtype=np.float32).ov_model - compressed_model_fp32 = compress_weights(model_fp32) - name_to_node_map = {op.get_friendly_name(): op for op in compressed_model_fp32.get_ops()} - assert "weights/scale_convert" in name_to_node_map - scale_multiply_node = name_to_node_map["weights/fq_weights_1"] - assert scale_multiply_node.input_value(1).get_node().get_element_type() == ov.Type.f32 - - # When model weight is in fp16, there will be no extra convert node for weight scale - model_fp16 = IdentityMatmul(weights_dtype=np.float16).ov_model - compressed_model_fp16 = compress_weights(model_fp16) - name_to_node_map = {op.get_friendly_name(): op for op in compressed_model_fp16.get_ops()} - assert "weights/scale_convert" not in name_to_node_map - scale_multiply_node = name_to_node_map["weights/fq_weights_1"] - assert scale_multiply_node.input_value(1).get_node().get_element_type() == ov.Type.f16 +def test_compression_for_different_dtypes(): + for activation_dtype in [np.float32, np.float16]: + for weight_dtype in [np.float32, np.float16]: + if activation_dtype == np.float16 and weight_dtype == np.float32: + # Activations can be in f16 only if weights are in f16 + continue + + model = IdentityMatmul(weights_dtype=weight_dtype, activation_dtype=activation_dtype).ov_model + compressed_model = compress_weights( + model, mode=CompressWeightsMode.INT4_SYM, ratio=1, group_size=1, all_layers=True + ) + name_to_node_map = {op.get_friendly_name(): op for op in compressed_model.get_ops()} + + # Weight scale should be in fp16 nevertheless the weight data type + scale_multiply_node = name_to_node_map["weights/fq_weights_1"] + assert scale_multiply_node.input_value(1).get_node().get_element_type() == ov.Type.f16 + + reshape_node = get_next_node(scale_multiply_node) + assert reshape_node.get_type_name() == "Reshape" + + next_node = get_next_node(reshape_node) + if activation_dtype == np.float16: + # There should be no convert node after multiply if both weights and activations are in f16 + assert next_node.get_type_name() != "Convert" + else: + assert next_node.get_type_name() == "Convert" + # In case weight is in fp32, the convert node is manually inserted + if weight_dtype == np.float32: + assert next_node.get_friendly_name() == "weights/fq_weights_1/convert" DATASET_SIZE = 129 From c33b1f21dfd0459f964092a632c26f1acf126425 Mon Sep 17 00:00:00 2001 From: Nikita Savelyev Date: Fri, 19 Apr 2024 18:13:08 +0200 Subject: [PATCH 05/12] Fix quantile parameter not being fed to NoOutliersAggregator constructor (#2641) ### Reason for change When `NoOutliersAggregator ` aggregator is used, `quantile` parameter was not provided to the aggregator constructor. --- .../algorithms/min_max/onnx_backend.py | 14 +++++++++----- .../algorithms/min_max/openvino_backend.py | 14 +++++++++----- .../algorithms/min_max/torch_backend.py | 14 +++++++++----- nncf/quantization/range_estimator.py | 4 +++- 4 files changed, 30 insertions(+), 16 deletions(-) diff --git a/nncf/quantization/algorithms/min_max/onnx_backend.py b/nncf/quantization/algorithms/min_max/onnx_backend.py index f58299a5d10..5f482c419e3 100644 --- a/nncf/quantization/algorithms/min_max/onnx_backend.py +++ b/nncf/quantization/algorithms/min_max/onnx_backend.py @@ -42,6 +42,7 @@ from nncf.quantization.algorithms.min_max.backend import MinMaxAlgoBackend from nncf.quantization.fake_quantize import FakeConvertParameters from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import AggregatorType from nncf.quantization.range_estimator import RangeEstimatorParameters @@ -211,11 +212,14 @@ def get_statistic_collector( statistic_type = StatisticsType.ABS_MAX reducer = ONNX_REDUCERS_MAP[statistic_type](**kwargs) - aggregator = AGGREGATORS_MAP[params.aggregator_type]( - num_samples=num_samples, - aggregation_axes=aggregation_axes, - tensor_processor=ONNXNNCFCollectorTensorProcessor, - ) + kwargs = { + "num_samples": num_samples, + "aggregation_axes": aggregation_axes, + "tensor_processor": ONNXNNCFCollectorTensorProcessor, + } + if params.aggregator_type in [AggregatorType.MEAN_NO_OUTLIERS, AggregatorType.MEDIAN_NO_OUTLIERS]: + kwargs.update({"quantile": params.quantile_outlier_prob}) + aggregator = AGGREGATORS_MAP[params.aggregator_type](**kwargs) collector.register_statistic_branch(container_key, reducer, aggregator) return collector diff --git a/nncf/quantization/algorithms/min_max/openvino_backend.py b/nncf/quantization/algorithms/min_max/openvino_backend.py index 417f9c7cbec..77c2dcd409c 100644 --- a/nncf/quantization/algorithms/min_max/openvino_backend.py +++ b/nncf/quantization/algorithms/min_max/openvino_backend.py @@ -42,6 +42,7 @@ from nncf.quantization.algorithms.min_max.backend import MinMaxAlgoBackend from nncf.quantization.fake_quantize import FakeConvertParameters from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import AggregatorType class OVMinMaxAlgoBackend(MinMaxAlgoBackend): @@ -195,11 +196,14 @@ def get_statistic_collector( statistic_type = StatisticsType.ABS_MAX reducer = OV_REDUCERS_MAP[statistic_type](**kwargs) - aggregator = AGGREGATORS_MAP[params.aggregator_type]( - num_samples=num_samples, - aggregation_axes=aggregation_axes, - tensor_processor=OVNNCFCollectorTensorProcessor, - ) + kwargs = { + "num_samples": num_samples, + "aggregation_axes": aggregation_axes, + "tensor_processor": OVNNCFCollectorTensorProcessor, + } + if params.aggregator_type in [AggregatorType.MEAN_NO_OUTLIERS, AggregatorType.MEDIAN_NO_OUTLIERS]: + kwargs.update({"quantile": params.quantile_outlier_prob}) + aggregator = AGGREGATORS_MAP[params.aggregator_type](**kwargs) collector.register_statistic_branch(container_key, reducer, aggregator) return collector diff --git a/nncf/quantization/algorithms/min_max/torch_backend.py b/nncf/quantization/algorithms/min_max/torch_backend.py index 541792eca78..f30fbcb8e8b 100644 --- a/nncf/quantization/algorithms/min_max/torch_backend.py +++ b/nncf/quantization/algorithms/min_max/torch_backend.py @@ -33,6 +33,7 @@ from nncf.quantization.algorithms.min_max.backend import MinMaxAlgoBackend from nncf.quantization.fake_quantize import FakeConvertParameters from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import AggregatorType from nncf.quantization.range_estimator import RangeEstimatorParameters from nncf.torch.graph.graph import PTNNCFGraph from nncf.torch.graph.graph import PTTargetPoint @@ -195,11 +196,14 @@ def get_statistic_collector( statistic_type = StatisticsType.ABS_MAX reducer = PT_REDUCERS_MAP[statistic_type](reduction_axes=reduction_axes) - aggregator = AGGREGATORS_MAP[params.aggregator_type]( - aggregation_axes=aggregation_axes, - num_samples=num_samples, - tensor_processor=PTNNCFCollectorTensorProcessor, - ) + kwargs = { + "num_samples": num_samples, + "aggregation_axes": aggregation_axes, + "tensor_processor": PTNNCFCollectorTensorProcessor, + } + if params.aggregator_type in [AggregatorType.MEAN_NO_OUTLIERS, AggregatorType.MEDIAN_NO_OUTLIERS]: + kwargs.update({"quantile": params.quantile_outlier_prob}) + aggregator = AGGREGATORS_MAP[params.aggregator_type](**kwargs) collector.register_statistic_branch(container_key, reducer, aggregator) return collector diff --git a/nncf/quantization/range_estimator.py b/nncf/quantization/range_estimator.py index d0eae69f480..49a48bedc51 100644 --- a/nncf/quantization/range_estimator.py +++ b/nncf/quantization/range_estimator.py @@ -74,7 +74,9 @@ class StatisticsCollectorParameters: :param clipping_value: The value to use for clipping the input tensors before collecting statistics. :type clipping_value: Optional[float] - :param quantile_outlier_prob: The outlier probability for quantile statistics. + :param quantile_outlier_prob: The outlier probability for QUANTILE statistic or MEAN_NO_OUTLIERS/MEDIAN_NO_OUTLIERS + aggregators. When using these together, please be aware that currently the quantile value will be applied to + both. :type quantile_outlier_prob: float """ From eb56bdf43ae43f1206545084e6a24d909380a91b Mon Sep 17 00:00:00 2001 From: Alexander Suslov Date: Sun, 21 Apr 2024 11:16:55 +0400 Subject: [PATCH 06/12] QAT anomaly example (#2582) ### Changes Added the example: Quantization-Aware Training of STFPM PyTorch model from Anomalib ### Reason for changes This example demonstrates how to quantize [Student-Teacher Feature Pyramid Matching (STFPM)](https://anomalib.readthedocs.io/en/latest/markdown/guides/reference/models/image/stfpm.html) PyTorch model from [Anomalib](https://github.com/openvinotoolkit/anomalib) using Quantization API from Neural Network Compression Framework (NNCF). ### Related tickets N/A ### Tests test_examples 323 --- .../torch/anomalib/README.md | 37 ++++ .../torch/anomalib/main.py | 190 ++++++++++++++++++ .../torch/anomalib/requirements.txt | 1 + tests/cross_fw/examples/example_scope.json | 25 +++ tests/cross_fw/examples/run_example.py | 21 ++ tests/cross_fw/examples/test_examples.py | 6 + 6 files changed, 280 insertions(+) create mode 100644 examples/quantization_aware_training/torch/anomalib/README.md create mode 100644 examples/quantization_aware_training/torch/anomalib/main.py create mode 100644 examples/quantization_aware_training/torch/anomalib/requirements.txt diff --git a/examples/quantization_aware_training/torch/anomalib/README.md b/examples/quantization_aware_training/torch/anomalib/README.md new file mode 100644 index 00000000000..fe649bf861d --- /dev/null +++ b/examples/quantization_aware_training/torch/anomalib/README.md @@ -0,0 +1,37 @@ +# Quantization-Aware Training of STFPM PyTorch model from Anomalib + +The anomaly detection domain is one of the domains in which models are used in scenarios where the cost of model error is high and accuracy cannot be sacrificed for better model performance. Quantization-Aware Training (QAT) is perfect for such cases, as it reduces quantization error without model performance degradation by training the model. + +This example demonstrates how to quantize [Student-Teacher Feature Pyramid Matching (STFPM)](https://anomalib.readthedocs.io/en/latest/markdown/guides/reference/models/image/stfpm.html) PyTorch model from [Anomalib](https://github.com/openvinotoolkit/anomalib) using Quantization API from Neural Network Compression Framework (NNCF). At the first step, the model is quantized using Post-Training Quantization (PTQ) algorithm to obtain the best initialization of the quantized model. If the accuracy of the quantized model after PTQ does not meet requirements, the next step is to train the quantized model using PyTorch framework. + +NNCF provides a seamless transition from Post-Training Quantization to Quantization-Aware Training without additional model preparation and transfer of magic parameters. + +The example includes the following steps: + +- Loading the [MVTec (capsule category)](https://www.mvtec.com/company/research/datasets/mvtec-ad) dataset (~4.9 Gb). +- (Optional) Training STFPM PyTorch model from scratch. +- Loading STFPM model pretrained on this dataset. +- Quantizing the model using NNCF Post-Training Quantization algorithm. +- Fine-tuning quantized model for one epoch to improve quantized model metrics. +- Output of the following characteristics of the quantized model: + - Accuracy drop of the quantized model (INT8) over the pre-trained model (FP32) + - Compression rate of the quantized model file size relative to the pre-trained model file size + - Performance speed up of the quantized model (INT8) + +## Install requirements + +At this point, it is assumed that you have already installed NNCF. You can find information on installation of NNCF [here](https://github.com/openvinotoolkit/nncf#user-content-installation). + +To work with the example you should install the corresponding Python package dependencies: + +```bash +pip install -r requirements.txt +``` + +## Run Example + +It's pretty simple. The example does not require additional preparation. It will do the preparation itself, such as loading the dataset and model, etc. + +```bash +python main.py +``` diff --git a/examples/quantization_aware_training/torch/anomalib/main.py b/examples/quantization_aware_training/torch/anomalib/main.py new file mode 100644 index 00000000000..5ad4f348db6 --- /dev/null +++ b/examples/quantization_aware_training/torch/anomalib/main.py @@ -0,0 +1,190 @@ +# Copyright (c) 2024 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 os +import re +import subprocess +import tarfile +from copy import deepcopy +from pathlib import Path +from typing import List +from urllib.request import urlretrieve + +import torch +from anomalib import TaskType +from anomalib.data import MVTec +from anomalib.data.image import mvtec +from anomalib.data.utils import download +from anomalib.deploy import ExportType +from anomalib.engine import Engine +from anomalib.models import Stfpm + +import nncf + +HOME_PATH = Path.home() +DATASET_PATH = HOME_PATH / ".cache/nncf/datasets/mvtec" +CHECKPOINT_PATH = HOME_PATH / ".cache/nncf/models/anomalib" +ROOT = Path(__file__).parent.resolve() +FP32_RESULTS_ROOT = ROOT / "fp32" +INT8_RESULTS_ROOT = ROOT / "int8" +CHECKPOINT_URL = "https://storage.openvinotoolkit.org/repositories/nncf/examples/torch/anomalib/stfpm_mvtec.ckpt" +USE_PRETRAINED = True + + +def download_and_extract(root: Path, info: download.DownloadInfo) -> None: + root.mkdir(parents=True, exist_ok=True) + downloaded_file_path = root / info.url.split("/")[-1] + print(f"Downloading the {info.name} dataset.") + with download.DownloadProgressBar(unit="B", unit_scale=True, miniters=1, desc=info.name) as progress_bar: + urlretrieve( + url=f"{info.url}", + filename=downloaded_file_path, + reporthook=progress_bar.update_to, + ) + print("Checking the hash of the downloaded file.") + download.check_hash(downloaded_file_path, info.hashsum) + print(f"Extracting the {info.name} dataset.") + with tarfile.open(downloaded_file_path) as tar_file: + tar_file.extractall(root) + print("Cleaning up files.") + downloaded_file_path.unlink() + + +def create_dataset(root: Path) -> MVTec: + if not root.exists(): + download_and_extract(root, mvtec.DOWNLOAD_INFO) + return MVTec(root) + + +def run_benchmark(model_path: Path, shape: List[int]) -> float: + command = f"benchmark_app -m {model_path} -d CPU -api async -t 15" + command += f' -shape "[{",".join(str(x) for x in shape)}]"' + cmd_output = subprocess.check_output(command, shell=True) # nosec + print(*str(cmd_output).split("\\n")[-9:-1], sep="\n") + match = re.search(r"Throughput\: (.+?) FPS", str(cmd_output)) + return float(match.group(1)) + + +def get_model_size(ir_path: Path, m_type: str = "Mb") -> float: + xml_size = ir_path.stat().st_size + bin_size = ir_path.with_suffix(".bin").stat().st_size + for t in ["bytes", "Kb", "Mb"]: + if m_type == t: + break + xml_size /= 1024 + bin_size /= 1024 + model_size = xml_size + bin_size + print(f"Model graph (xml): {xml_size:.3f} Mb") + print(f"Model weights (bin): {bin_size:.3f} Mb") + print(f"Model size: {model_size:.3f} Mb") + return model_size + + +def main(): + ############################################################################### + # Step 1: Prepare the model and dataset + print(os.linesep + "[Step 1] Prepare the model and dataset") + + model = Stfpm() + datamodule = create_dataset(root=DATASET_PATH) + + # Create an engine for the original model + engine = Engine(task=TaskType.SEGMENTATION, default_root_dir=FP32_RESULTS_ROOT, devices=1) + if USE_PRETRAINED: + # Load the pretrained checkpoint + CHECKPOINT_PATH.mkdir(parents=True, exist_ok=True) + ckpt_path = CHECKPOINT_PATH / "stfpm_mvtec.ckpt" + torch.hub.download_url_to_file(CHECKPOINT_URL, ckpt_path) + else: + # (Optional) Train the model from scratch + engine.fit(model=model, datamodule=datamodule) + ckpt_path = engine.trainer.checkpoint_callback.best_model_path + + print("Test results for original FP32 model:") + fp32_test_results = engine.test(model=model, datamodule=datamodule, ckpt_path=ckpt_path) + + ############################################################################### + # Step 2: Quantize the model + print(os.linesep + "[Step 2] Quantize the model") + + # Create calibration dataset + def transform_fn(data_item): + return data_item["image"] + + test_loader = datamodule.test_dataloader() + calibration_dataset = nncf.Dataset(test_loader, transform_fn) + + # Quantize the inference model using Post-Training Quantization + inference_model = model.model + quantized_inference_model = nncf.quantize(model=inference_model, calibration_dataset=calibration_dataset) + + # Deepcopy the original model and set the quantized inference model + quantized_model = deepcopy(model) + quantized_model.model = quantized_inference_model + + # Create engine for the quantized model + engine = Engine(task=TaskType.SEGMENTATION, default_root_dir=INT8_RESULTS_ROOT, max_epochs=1, devices=1) + + # Validate the quantized model + print("Test results for INT8 model after PTQ:") + int8_init_test_results = engine.test(model=quantized_model, datamodule=datamodule) + + ############################################################################### + # Step 3: Fine tune the quantized model + print(os.linesep + "[Step 3] Fine tune the quantized model") + + engine.fit(model=quantized_model, datamodule=datamodule) + print("Test results for INT8 model after QAT:") + int8_test_results = engine.test(model=quantized_model, datamodule=datamodule) + + ############################################################################### + # Step 4: Export models + print(os.linesep + "[Step 4] Export models") + + # Export FP32 model to OpenVINO™ IR + fp32_ir_path = engine.export(model=model, export_type=ExportType.OPENVINO, export_root=FP32_RESULTS_ROOT) + print(f"Original model path: {fp32_ir_path}") + fp32_size = get_model_size(fp32_ir_path) + + # Export INT8 model to OpenVINO™ IR + int8_ir_path = engine.export(model=quantized_model, export_type=ExportType.OPENVINO, export_root=INT8_RESULTS_ROOT) + print(f"Quantized model path: {int8_ir_path}") + int8_size = get_model_size(int8_ir_path) + + ############################################################################### + # Step 5: Run benchmarks + print(os.linesep + "[Step 5] Run benchmarks") + + print("Run benchmark for FP32 model (IR)...") + fp32_fps = run_benchmark(fp32_ir_path, shape=[1, 3, 256, 256]) + + print("Run benchmark for INT8 model (IR)...") + int8_fps = run_benchmark(int8_ir_path, shape=[1, 3, 256, 256]) + + ############################################################################### + # Step 6: Summary + print(os.linesep + "[Step 6] Summary") + + fp32_f1score = fp32_test_results[0]["image_F1Score"] + int8_init_f1score = int8_init_test_results[0]["image_F1Score"] + int8_f1score = int8_test_results[0]["image_F1Score"] + + print(f"Accuracy drop after PTQ: {fp32_f1score - int8_init_f1score:.3f}") + print(f"Accuracy drop after QAT: {fp32_f1score - int8_f1score:.3f}") + print(f"Model compression rate: {fp32_size / int8_size:.3f}") + # https://docs.openvino.ai/latest/openvino_docs_optimization_guide_dldt_optimization_guide.html + print(f"Performance speed up (throughput mode): {int8_fps / fp32_fps:.3f}") + + return fp32_f1score, int8_init_f1score, int8_f1score, fp32_fps, int8_fps, fp32_size, int8_size + + +if __name__ == "__main__": + main() diff --git a/examples/quantization_aware_training/torch/anomalib/requirements.txt b/examples/quantization_aware_training/torch/anomalib/requirements.txt new file mode 100644 index 00000000000..16bfe3c7f2c --- /dev/null +++ b/examples/quantization_aware_training/torch/anomalib/requirements.txt @@ -0,0 +1 @@ +anomalib[core,openvino]==1.0.0 \ No newline at end of file diff --git a/tests/cross_fw/examples/example_scope.json b/tests/cross_fw/examples/example_scope.json index 9d834b920fd..7bf8d749739 100644 --- a/tests/cross_fw/examples/example_scope.json +++ b/tests/cross_fw/examples/example_scope.json @@ -210,5 +210,30 @@ "ratio": 1.0, "group_size": 64 } + }, + "quantization_aware_training_torch_anomalib": { + "backend": "torch", + "requirements": "examples/quantization_aware_training/torch/anomalib/requirements.txt", + "cpu": "Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz", + "python_version": [3,10,0], + "accuracy_tolerance_after_training": 0.02, + "accuracy_metrics": { + "fp32_f1score": 0.9919999837875366, + "int8_init_f1score": 0.9767441749572754 + }, + "accuracy_metrics_after_training":{ + "int8_f1score": 0.9919999837875366, + "accuracy_drop": 0.0 + }, + "performance_metrics": { + "fp32_fps": 316.28, + "int8_fps": 879.84, + "performance_speed_up": 2.7818388769444797 + }, + "model_size_metrics": { + "fp32_model_size": 21.37990665435791, + "int8_model_size": 5.677968978881836, + "model_compression_rate": 3.7654144877995197 + } } } \ No newline at end of file diff --git a/tests/cross_fw/examples/run_example.py b/tests/cross_fw/examples/run_example.py index dc44a00e650..385b3a4799c 100644 --- a/tests/cross_fw/examples/run_example.py +++ b/tests/cross_fw/examples/run_example.py @@ -212,6 +212,27 @@ def set_torch_cuda_seed(seed: int = 42): os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8" +def quantization_aware_training_torch_anomalib(): + from examples.quantization_aware_training.torch.anomalib.main import main as anomalib_main + + # Set manual seed and determenistic cuda mode to make the test determenistic + set_torch_cuda_seed() + results = anomalib_main() + + return { + "fp32_f1score": float(results[0]), + "int8_init_f1score": float(results[1]), + "int8_f1score": float(results[2]), + "accuracy_drop": float(results[0] - results[2]), + "fp32_fps": results[3], + "int8_fps": results[4], + "performance_speed_up": results[4] / results[3], + "fp32_model_size": results[5], + "int8_model_size": results[6], + "model_compression_rate": results[5] / results[6], + } + + def main(argv): parser = ArgumentParser() parser.add_argument("--name", help="Example name", required=True) diff --git a/tests/cross_fw/examples/test_examples.py b/tests/cross_fw/examples/test_examples.py index 9dc38ea2d24..a49e2632107 100644 --- a/tests/cross_fw/examples/test_examples.py +++ b/tests/cross_fw/examples/test_examples.py @@ -11,6 +11,7 @@ import os import subprocess +import sys from pathlib import Path from typing import Any, Dict, List @@ -53,6 +54,11 @@ def test_examples( is_check_performance: bool, ov_version_override: str, ): + python_version = sys.version_info + example_python_version = tuple(example_params.get("python_version", python_version)) + if python_version < example_python_version: + pytest.skip(f"The test is skipped because python >= {example_python_version} is required.") + backend = example_params["backend"] skip_if_backend_not_selected(backend, backends_list) venv_path = create_venv_with_nncf(tmp_path, "pip_e_local", "venv", set([backend])) From d3a3fe96190721c778156b14001e92de7dc594c2 Mon Sep 17 00:00:00 2001 From: Nikita Malinin Date: Mon, 22 Apr 2024 08:50:37 +0200 Subject: [PATCH 07/12] Release notes 2.10 (#2640) ### Changes - Added v2.10.0 template; ### Reason for changes - Upcoming release; ### Related tickets - 138131; #### For the contributors: 1. Please add your changes (as the commit to the branch) to the list according to the template and previous notes; 2. Do not add tests-related notes; 3. Provide the list of the PRs (for all your notes) in the comment for the discussion; --------- Co-authored-by: Liubov Talamanova Co-authored-by: Daniil Lyakhov Co-authored-by: Nikita Savelyev --- ReleaseNotes.md | 52 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/ReleaseNotes.md b/ReleaseNotes.md index 58b37cd0a1a..cb49903134d 100644 --- a/ReleaseNotes.md +++ b/ReleaseNotes.md @@ -1,5 +1,57 @@ # Release Notes +## New in Release 2.10.0 + +Post-training Quantization: + +- Features: + - Introduced the subgraph defining functionality for the `nncf.IgnoredScope()` option. + - Introduced limited support for the batch size of more than 1. MobilenetV2 [PyTorch example](examples/post_training_quantization/torch/mobilenet_v2) was updated with batch support. +- Fixes: + - Fixed issue with the `nncf.OverflowFix` parameter absence in some scenarios. + - Aligned the list of correctable layers for the FastBiasCorrection algorithm between PyTorch, OpenVINO and ONNX backends. + - Fixed issue with the `nncf.QuantizationMode` parameters combination. + - Fixed MobilenetV2 ([PyTorch](examples/post_training_quantization/torch/mobilenet_v2), [ONNX](examples/post_training_quantization/onnx/mobilenet_v2), [OpenVINO](examples/post_training_quantization/openvino/mobilenet_v2)) examples for the Windows platform. + - (OpenVINO) Fixed [Anomaly Classification example](examples/post_training_quantization/openvino/anomaly_stfpm_quantize_with_accuracy_control) for the Windows platform. + - (PyTorch) Fixed bias shift magnitude calculation for fused layers. + - (OpenVINO) Fixed removing the ShapeOf graph which led to an error in the `nncf.quantize_with_accuracy_control()` method. +- Improvements: + - `OverflowFix`, `AdvancedSmoothQuantParameters` and `AdvancedBiasCorrectionParameters` were exposed into the `nncf.*` namespace. + - (OpenVINO, PyTorch) Introduced scale compression to FP16 for weights in `nncf.compress_weights()` method, regardless of model weights precision. + - (PyTorch) Modules that NNCF inserted were excluded from parameter tracing. + - (OpenVINO) Extended the list of correctable layers for the BiasCorrection algorithm. + - (ONNX) Aligned BiasCorrection algorithm behaviour with OpenVINO in specific cases. +- Tutorials: + - [Post-Training Optimization of PhotoMaker Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/photo-maker/photo-maker.ipynb) + - [Post-Training Optimization of Stable Diffusion XL Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/stable-diffusion-xl/stable-diffusion-xl.ipynb) + - [Post-Training Optimization of KerasCV Stable Diffusion Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/stable-diffusion-keras-cv/stable-diffusion-keras-cv.ipynb) + - [Post-Training Optimization of Paint By Example Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/paint-by-example/paint-by-example.ipynb) + - [Post-Training Optimization of aMUSEd Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/amused-lightweight-text-to-image/amused-lightweight-text-to-image.ipynb) + - [Post-Training Optimization of InstantID Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/instant-id/instant-id.ipynb) + - [Post-Training Optimization of LLaVA Next Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/llava-next-multimodal-chatbot/llava-next-multimodal-chatbot.ipynb) + - [Post-Training Optimization of AnimateAnyone Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/animate-anyone/animate-anyone.ipynb) + - [Post-Training Optimization of YOLOv8-OBB Model](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/yolov8-optimization/yolov8-obb.ipynb) + - [Post-Training Optimization of LLM Agent](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/llm-agent-langchain/llm-agent-langchain.ipynb) + +Compression-aware training: + +- Features: + - (PyTorch) `nncf.quantize` method now may be used as quantization initialization for Quantization-Aware Training. Added a [Resnet18-based example](examples/quantization_aware_training/torch/resnet18) with the transition from the Post-Training Quantization to a Quantization-Aware Training algorithm. + - (PyTorch) Introduced extractors for the fused Convolution, Batch-/GroupNorm, and Linear functions. +- Fixes: + - (PyTorch) Fixed `apply_args_defaults` function issue. + - (PyTorch) Fixed `dtype` handling for the compressed `torch.nn.Parameter`. + - (PyTorch) Fixed `is_shared` parameter propagation. +- Improvements: + - (PyTorch) Updated command creation behaviour to reduce the number of adapters. + - (PyTorch) Added option to insert point for models that wrapped with `replace_modules=False`. +- Deprecations/Removals: + - (PyTorch) Removed the `binarization` algorithm. + - NNCF installation via `pip install nncf[]` option is now deprecated. +- Requirements: + - Updated PyTorch (2.2.1) and CUDA (12.1) versions. + - Updated ONNX (1.16.0) and ONNXRuntime (1.17.1) versions. + ## New in Release 2.9.0 Post-training Quantization: From fa1a4ceabee06e10f7dfb42ce12bdd9b04ed4b79 Mon Sep 17 00:00:00 2001 From: Aleksei Kashapov Date: Mon, 22 Apr 2024 11:20:23 +0200 Subject: [PATCH 08/12] [PTQ] batch_size in PTQ docs (#2619) ### Changes Add documentation regarding batch_size ### Reason for changes To meet users with influence of batch_size on quantization ### Related tickets 121650 ### Tests N/A --- .../post_training/Quantization.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/compression_algorithms/post_training/Quantization.md b/docs/compression_algorithms/post_training/Quantization.md index f5e3542e2b8..03a783a43c6 100644 --- a/docs/compression_algorithms/post_training/Quantization.md +++ b/docs/compression_algorithms/post_training/Quantization.md @@ -91,3 +91,13 @@ NNCF provides the examples of Post-Training Quantization where you can find the function: [PyTorch](../../../examples/post_training_quantization/torch/mobilenet_v2/README.md), [TensorFlow](../../../examples/post_training_quantization/tensorflow/mobilenet_v2/README.md), [ONNX](../../../examples/post_training_quantization/onnx/mobilenet_v2/README.md), and [OpenVINO](../../../examples/post_training_quantization/openvino/mobilenet_v2/README.md) In case the Post-Training Quantization algorithm could not reach quality requirements you can fine-tune a quantized pytorch model. Example of the Quantization-Aware training pipeline for a pytorch model could be found [here](../../../examples/quantization_aware_training/torch/resnet18/README.md). + +## Using `pytorch.Dataloader` or `tf.data.Dataset` as data source for calibration dataset + +```batch_size``` is a parameter of a dataloader that refers to the number of samples or data points propagated through the neural network in a single pass. + +NNCF allows for dataloaders with different batch sizes, but there are limitations. For models like transformers or those with unconventional tensor structures, such as the batch axis not being in the expected position, using batch sizes larger than 1 for quantization isn't supported. It happens because certain models' internal data arrangements may not align with the assumptions made during quantization, leading to inaccurate statistics calculation issues with batch sizes larger than 1. + +Please keep in mind that you have to recalculate the subset size for quantization according to the batch size using the following formula: ```subset_size = subset_size_for_batch_size_1 // batch_size.```. + +[Example](../../../examples/post_training_quantization/torch/mobilenet_v2/README.md) with post-training quantization for PyTorch with a dataloader having a ```batch_size``` of 128. From 590bc6d1372f3ae08b1bb7d18889c7cff575bffa Mon Sep 17 00:00:00 2001 From: Alexander Dokuchaev Date: Wed, 24 Apr 2024 08:50:11 +0300 Subject: [PATCH 09/12] [PT] Support custom modules in PTQ (#2461) ### Changes - Wrap model with tracing of parameters for PTQ. - `PTModelExtractionWithFusedBiasCommand` to `PTModelExtractionCommand` - Removed model_analyzer.py - Renamed PTDepthwiseConv3dSubtype to PTModuleDepthwiseConv3dSubtype metatype - Added PTModuleDepthwiseConv3dSubtype - Added is_subtype to OperatorMetatypeRegistry.register ### Reason for changes Support models with custom modules. ### Related tickets 129581 --- .../bootstrapNAS/elasticity/elastic_width.py | 6 +- .../elasticity/multi_elasticity_handler.py | 12 +- .../bootstrapNAS/elasticity/visualization.py | 4 +- .../fast_bias_correction/algorithm.py | 14 +- .../fast_bias_correction/torch_backend.py | 14 +- .../algorithms/min_max/algorithm.py | 6 +- .../algorithms/min_max/torch_backend.py | 20 +- .../algorithms/smooth_quant/torch_backend.py | 23 +- nncf/torch/graph/graph_builder.py | 9 +- nncf/torch/graph/operator_metatypes.py | 105 +- .../graph/transformations/command_creation.py | 3 - nncf/torch/graph/transformations/commands.py | 9 +- nncf/torch/model_analyzer.py | 98 - nncf/torch/model_graph_manager.py | 39 +- nncf/torch/model_transformer.py | 59 +- nncf/torch/pruning/filter_pruning/algo.py | 12 +- nncf/torch/quantization/algo.py | 4 +- .../quantization/default_quantization.py | 2 + nncf/torch/quantization/quantize_model.py | 2 +- nncf/torch/quantization/strip.py | 3 + .../pipelines/image_classification_timm.py | 4 - .../quantized/ptq/symmetric/alexnet.dot | 180 +- .../quantized/ptq/symmetric/densenet121.dot | 3768 ++++++++++------- .../ptq/symmetric/embedding_model.dot | 26 +- .../quantized/ptq/symmetric/inception.dot | 1954 +++++---- .../quantized/ptq/symmetric/inception_v3.dot | 2694 +++++++----- .../quantized/ptq/symmetric/lenet.dot | 108 +- .../quantized/ptq/symmetric/mobilenet_v2.dot | 1416 ++++--- .../ptq/symmetric/mobilenet_v3_small.dot | 1330 +++--- .../quantized/ptq/symmetric/resnet18.dot | 620 +-- .../ptq/symmetric/resnet50_cpu_spr.dot | 1490 ++++--- .../quantized/ptq/symmetric/shared_model.dot | 36 +- .../quantized/ptq/symmetric/shufflenetv2.dot | 1800 ++++---- .../quantized/ptq/symmetric/squeezenet1_1.dot | 596 +-- .../quantized/ptq/symmetric/ssd_mobilenet.dot | 1234 +++--- .../quantized/ptq/symmetric/ssd_vgg.dot | 1041 +++-- .../quantized/ptq/symmetric/unet.dot | 640 +-- .../quantized/ptq/symmetric/vgg16.dot | 412 +- ...TwoConvTestModel_overflow_fix_disable.json | 20 +- .../TwoConvTestModel_overflow_fix_enable.json | 20 +- ...stModel_overflow_fix_first_layer_only.json | 20 +- tests/torch/helpers.py | 33 +- tests/torch/ptq/helpers.py | 20 +- .../ptq/test_calculation_quantizer_params.py | 16 +- tests/torch/ptq/test_fast_bias_correction.py | 4 +- tests/torch/ptq/test_fq_params_calculation.py | 6 +- tests/torch/ptq/test_graphs.py | 5 +- tests/torch/ptq/test_ptq_params.py | 8 +- tests/torch/ptq/test_smooth_quant.py | 26 +- tests/torch/ptq/test_strip.py | 4 +- tests/torch/test_layer_attributes.py | 8 +- tests/torch/test_model_analyzer.py | 67 - tests/torch/test_model_graph_manager.py | 49 + tests/torch/test_model_transformer.py | 45 +- tests/torch/test_statistics_aggregator.py | 36 +- 55 files changed, 12137 insertions(+), 8043 deletions(-) delete mode 100644 nncf/torch/model_analyzer.py delete mode 100644 tests/torch/test_model_analyzer.py diff --git a/nncf/experimental/torch/nas/bootstrapNAS/elasticity/elastic_width.py b/nncf/experimental/torch/nas/bootstrapNAS/elasticity/elastic_width.py index 227a4d16fee..0d3114e0b26 100644 --- a/nncf/experimental/torch/nas/bootstrapNAS/elasticity/elastic_width.py +++ b/nncf/experimental/torch/nas/bootstrapNAS/elasticity/elastic_width.py @@ -48,9 +48,9 @@ from nncf.experimental.torch.nas.bootstrapNAS.elasticity.elasticity_dim import ElasticityDim from nncf.experimental.torch.nas.bootstrapNAS.elasticity.filter_reorder import FilterReorderingAlgorithm from nncf.torch.graph.graph import PTNNCFGraph -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleBatchNormMetatype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleLayerNormMetatype from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype from nncf.torch.graph.transformations.commands import PTInsertionCommand @@ -1027,7 +1027,7 @@ def build(self, target_model: NNCFNetwork) -> ElasticWidthHandler: metatype_vs_elastic_op_creator = { PTModuleConv2dMetatype: self._create_elastic_conv_width_op, - PTDepthwiseConv2dSubtype: self._create_elastic_conv_width_op, + PTModuleDepthwiseConv2dSubtype: self._create_elastic_conv_width_op, PTModuleLinearMetatype: self._create_elastic_linear_width_op, } @@ -1078,7 +1078,7 @@ def build(self, target_model: NNCFNetwork) -> ElasticWidthHandler: metatype_vs_dynamic_input_op_creator = { PTModuleConv2dMetatype: self._create_dynamic_conv_input_op, - PTDepthwiseConv2dSubtype: self._create_dynamic_dw_conv_input_op, + PTModuleDepthwiseConv2dSubtype: self._create_dynamic_dw_conv_input_op, PTModuleBatchNormMetatype: self._create_dynamic_bn_input_op, PTModuleLayerNormMetatype: self._create_dynamic_ln_input_op, PTModuleLinearMetatype: self._create_dynamic_linear_input_op, diff --git a/nncf/experimental/torch/nas/bootstrapNAS/elasticity/multi_elasticity_handler.py b/nncf/experimental/torch/nas/bootstrapNAS/elasticity/multi_elasticity_handler.py index 4daa23a0baf..08f92360e2d 100644 --- a/nncf/experimental/torch/nas/bootstrapNAS/elasticity/multi_elasticity_handler.py +++ b/nncf/experimental/torch/nas/bootstrapNAS/elasticity/multi_elasticity_handler.py @@ -26,14 +26,14 @@ from nncf.experimental.torch.nas.bootstrapNAS.elasticity.elastic_width import ElasticWidthHandler from nncf.experimental.torch.nas.bootstrapNAS.elasticity.elastic_width import ElasticWidthSearchSpace from nncf.experimental.torch.nas.bootstrapNAS.elasticity.elasticity_dim import ElasticityDim -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv1dSubtype -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv3dSubtype from nncf.torch.graph.operator_metatypes import PTModuleConv1dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConv3dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConvTranspose2dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConvTranspose3dMetatype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv1dSubtype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv3dSubtype from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype from nncf.torch.nncf_network import NNCFNetwork from nncf.torch.pruning.utils import collect_output_shapes @@ -60,11 +60,11 @@ class MultiElasticityHandler(ElasticityHandler): def __init__(self, handlers: OrderedDictType[ElasticityDim, SingleElasticityHandler], target_model: NNCFNetwork): GENERAL_CONV_LAYER_METATYPES = [ PTModuleConv1dMetatype, - PTDepthwiseConv1dSubtype, + PTModuleDepthwiseConv1dSubtype, PTModuleConv2dMetatype, - PTDepthwiseConv2dSubtype, + PTModuleDepthwiseConv2dSubtype, PTModuleConv3dMetatype, - PTDepthwiseConv3dSubtype, + PTModuleDepthwiseConv3dSubtype, PTModuleConvTranspose2dMetatype, PTModuleConvTranspose3dMetatype, ] diff --git a/nncf/experimental/torch/nas/bootstrapNAS/elasticity/visualization.py b/nncf/experimental/torch/nas/bootstrapNAS/elasticity/visualization.py index 4e1e6ddbe56..4f59a785ac3 100644 --- a/nncf/experimental/torch/nas/bootstrapNAS/elasticity/visualization.py +++ b/nncf/experimental/torch/nas/bootstrapNAS/elasticity/visualization.py @@ -19,8 +19,8 @@ from nncf.experimental.torch.nas.bootstrapNAS.elasticity.elastic_width import ElasticWidthHandler from nncf.experimental.torch.nas.bootstrapNAS.elasticity.multi_elasticity_handler import MultiElasticityHandler from nncf.torch.graph.graph import PTNNCFGraph -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype class SubnetGraph: @@ -38,7 +38,7 @@ def __init__(self, compression_graph: PTNNCFGraph, multi_elasticity_handler: Mul color = None if metatype == PTModuleConv2dMetatype: color = "lightblue" - if metatype == PTDepthwiseConv2dSubtype: + if metatype == PTModuleDepthwiseConv2dSubtype: operator_name = f"DW_{operator_name}" color = "purple" diff --git a/nncf/quantization/algorithms/fast_bias_correction/algorithm.py b/nncf/quantization/algorithms/fast_bias_correction/algorithm.py index 15f9a2f05b1..f29d41a3e7c 100644 --- a/nncf/quantization/algorithms/fast_bias_correction/algorithm.py +++ b/nncf/quantization/algorithms/fast_bias_correction/algorithm.py @@ -154,7 +154,10 @@ def apply( input_fp, input_shape = self._get_fp_inputs(statistic_points, in_node_name) output_fp = self._get_fp_outputs(statistic_points, out_node_name) - extracted_model = self._extract_submodel(model_transformer, node_name) + extracted_model = self._extract_submodel(model_transformer, in_node_name, out_node_name) + if extracted_model is None: + nncf_logger.debug(f"Skipping node {node_name} because cant extract submodel") + continue sub_input_name, sub_output_name = self._backend_entity.get_sub_input_output_names(extracted_model) @@ -267,15 +270,18 @@ def output_filter_func(point): output_fp.extend(Tensor(tensor_collector.get_statistics().mean_values)) return output_fp - def _extract_submodel(self, model_transformer: ModelTransformer, node_name: str) -> TModel: + def _extract_submodel(self, model_transformer: ModelTransformer, in_node_name: str, out_node_name: str) -> TModel: """ Extracts sub-model using backend-specific ModelTransformer. :param model_transformer: Backend-specific ModelTransformer. - :param node_name: Name of the node that should be a center of the sub-model. + :param in_node_name: Name of the start node. + :param out_node_name: Name of the output node. :return: Backend-specific sub-model. """ - model_extraction_command = self._backend_entity.model_extraction_command([(node_name, 0)], [(node_name, 0)]) + model_extraction_command = self._backend_entity.model_extraction_command( + [(in_node_name, 0)], [(out_node_name, 0)] + ) me_transformation_layout = TransformationLayout() me_transformation_layout.register(model_extraction_command) extracted_model = model_transformer.transform(me_transformation_layout) diff --git a/nncf/quantization/algorithms/fast_bias_correction/torch_backend.py b/nncf/quantization/algorithms/fast_bias_correction/torch_backend.py index 7623fdb0012..0099996883c 100644 --- a/nncf/quantization/algorithms/fast_bias_correction/torch_backend.py +++ b/nncf/quantization/algorithms/fast_bias_correction/torch_backend.py @@ -23,12 +23,12 @@ from nncf.quantization.algorithms.fast_bias_correction.backend import FastBiasCorrectionAlgoBackend from nncf.torch.graph.transformations.command_creation import create_bias_correction_command from nncf.torch.graph.transformations.commands import PTBiasCorrectionCommand -from nncf.torch.graph.transformations.commands import PTModelExtractionWithFusedBiasCommand +from nncf.torch.graph.transformations.commands import PTModelExtractionCommand from nncf.torch.graph.transformations.commands import PTTargetPoint -from nncf.torch.model_analyzer import get_fused_bias_value -from nncf.torch.model_analyzer import get_potential_fused_node -from nncf.torch.model_analyzer import is_node_with_fused_bias -from nncf.torch.model_analyzer import is_quantized_weights +from nncf.torch.model_graph_manager import get_fused_bias_value +from nncf.torch.model_graph_manager import get_potential_fused_node +from nncf.torch.model_graph_manager import is_node_with_fused_bias +from nncf.torch.model_graph_manager import is_quantized_weights from nncf.torch.nncf_network import NNCFNetwork from nncf.torch.tensor_statistics.collectors import get_mean_statistic_collector @@ -56,8 +56,8 @@ def create_bias_correction_command( @staticmethod def model_extraction_command( input_ids: List[Tuple[str, int]], output_ids: List[Tuple[str, int]] - ) -> PTModelExtractionWithFusedBiasCommand: - return PTModelExtractionWithFusedBiasCommand(input_ids[0][0]) + ) -> PTModelExtractionCommand: + return PTModelExtractionCommand([input_ids[0][0]], [output_ids[0][0]]) @staticmethod def mean_statistic_collector( diff --git a/nncf/quantization/algorithms/min_max/algorithm.py b/nncf/quantization/algorithms/min_max/algorithm.py index 92b2d5067f5..8e707e6b58c 100644 --- a/nncf/quantization/algorithms/min_max/algorithm.py +++ b/nncf/quantization/algorithms/min_max/algorithm.py @@ -12,7 +12,7 @@ import collections import dataclasses from copy import deepcopy -from typing import Any, Dict, List, Optional, OrderedDict, Set, TypeVar, Union +from typing import Any, Dict, List, Optional, OrderedDict, Set, Tuple, TypeVar, Union import numpy as np @@ -681,7 +681,7 @@ def _get_activation_quantization_target_point( def _get_quantization_target_points( self, model: TModel, nncf_graph: NNCFGraph - ) -> OrderedDict[TargetPoint, QuantizerConfig]: + ) -> Tuple[OrderedDict[TargetPoint, QuantizerConfig], List[List[TargetPoint]]]: """ Returns Quantization Target Points. In the Compression Pipeline logic NNCF assumes that the compression pipeline works only on the single model. @@ -1053,7 +1053,7 @@ def _is_node_after_producers(node): quantizer_setup.discard(fq_2_q_key, True) continue - # In the case of the two quantizers without the brancking after them, + # In the case of the two quantizers without the branching after them, # it needs to check that all quantizers follows after producer nodes. if _is_node_after_producers(fq_1_producer) and _is_node_after_producers(fq_2_producer): fq_1_prod_shape = np.prod(nncf_graph.get_output_edges(fq_1_producer)[0].tensor_shape) diff --git a/nncf/quantization/algorithms/min_max/torch_backend.py b/nncf/quantization/algorithms/min_max/torch_backend.py index f30fbcb8e8b..a735ad59cb9 100644 --- a/nncf/quantization/algorithms/min_max/torch_backend.py +++ b/nncf/quantization/algorithms/min_max/torch_backend.py @@ -62,7 +62,7 @@ class PTMinMaxAlgoBackend(MinMaxAlgoBackend): @property def mat_mul_metatypes(self) -> List[OperatorMetatype]: - return [om.PTModuleLinearMetatype, om.PTLinearMetatype, om.PTMatMulMetatype] + return [om.PTLinearMetatype, om.PTMatMulMetatype] @property def post_processing_metatypes(self) -> List[OperatorMetatype]: @@ -82,18 +82,18 @@ def read_variable_metatypes(self) -> List[OperatorMetatype]: @property def conv_metatypes(self) -> List[OperatorMetatype]: - return [om.PTModuleConv1dMetatype, om.PTModuleConv2dMetatype, om.PTModuleConv3dMetatype] + return [om.PTConv1dMetatype, om.PTConv2dMetatype, om.PTConv3dMetatype] @property def overflow_fix_metatypes(self) -> List[OperatorMetatype]: return [ - om.PTModuleConv1dMetatype, - om.PTModuleConv2dMetatype, - om.PTModuleConv3dMetatype, - om.PTModuleLinearMetatype, - om.PTModuleConvTranspose1dMetatype, - om.PTModuleConvTranspose2dMetatype, - om.PTModuleConvTranspose3dMetatype, + om.PTConv1dMetatype, + om.PTConv2dMetatype, + om.PTConv3dMetatype, + om.PTLinearMetatype, + om.PTConvTranspose1dMetatype, + om.PTConvTranspose2dMetatype, + om.PTConvTranspose3dMetatype, ] @property @@ -210,7 +210,7 @@ def get_statistic_collector( @staticmethod def get_weight_tensor_port_ids(node: NNCFNode) -> List[Optional[int]]: - return [None] + return node.metatype.weight_port_ids @staticmethod def get_weight_name(nncf_graph: NNCFGraph, target_point: PTTargetPoint) -> str: diff --git a/nncf/quantization/algorithms/smooth_quant/torch_backend.py b/nncf/quantization/algorithms/smooth_quant/torch_backend.py index 275f9a2523e..19154231dbc 100644 --- a/nncf/quantization/algorithms/smooth_quant/torch_backend.py +++ b/nncf/quantization/algorithms/smooth_quant/torch_backend.py @@ -30,6 +30,8 @@ from nncf.torch.graph.transformations.command_creation import create_command_to_update_weight from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand from nncf.torch.graph.transformations.commands import PTTargetPoint +from nncf.torch.model_graph_manager import get_const_data +from nncf.torch.model_graph_manager import get_const_node from nncf.torch.nncf_network import NNCFNetwork from nncf.torch.quantization.default_quantization import DEFAULT_PT_QUANT_TRAIT_TO_OP_DICT from nncf.torch.tensor_statistics.collectors import PTAbsMaxReducer @@ -52,14 +54,14 @@ class PTSmoothQuantAlgoBackend(SmoothQuantAlgoBackend): @property def convolution_metatypes(self) -> List[OperatorMetatype]: return [ - om.PTModuleConv1dMetatype, - om.PTModuleConv2dMetatype, - om.PTModuleConv3dMetatype, + om.PTConv1dMetatype, + om.PTConv2dMetatype, + om.PTConv3dMetatype, ] @property def matmul_metatypes(self) -> List[OperatorMetatype]: - return [om.PTModuleLinearMetatype] + return [om.PTLinearMetatype] @property def quantize_agnostic_metatypes(self) -> List[OperatorMetatype]: @@ -98,10 +100,13 @@ def get_abs_max_channel_collector( @staticmethod def get_weight_value(node_with_weight: NNCFNode, model: NNCFNetwork) -> Tensor: - node_module = model.nncf.get_containing_module(node_with_weight.node_name) - if node_module.weight is None: - raise RuntimeError(f"{node_module} module has no .weight attribute.") - return Tensor(node_module.weight.data) + weight_node = get_const_node( + node_with_weight, node_with_weight.metatype.weight_port_ids[0], model.nncf.get_graph() + ) + if weight_node is None: + raise RuntimeError(f"{node_with_weight} node has no weight node.") + weight_data = get_const_data(weight_node, model) + return Tensor(weight_data) @staticmethod def get_weight_tensor_port_id(node: NNCFNode) -> int: @@ -131,7 +136,7 @@ def scale_insertion_command( @staticmethod def get_activation_channel_axis(node: NNCFNode, port_id: int) -> int: - if node.metatype == om.PTModuleLinearMetatype: + if node.metatype == om.PTLinearMetatype: return -1 # TODO: Add activation axis calculation when MatMul will be supported return 1 diff --git a/nncf/torch/graph/graph_builder.py b/nncf/torch/graph/graph_builder.py index dc5842faf6f..7e8b3a38992 100644 --- a/nncf/torch/graph/graph_builder.py +++ b/nncf/torch/graph/graph_builder.py @@ -15,6 +15,7 @@ from nncf.common.graph import NNCFGraph from nncf.common.graph import NNCFNode +from nncf.common.graph.definitions import MODEL_CONST_OP_NAME from nncf.common.graph.operator_metatypes import CONST_NOOP_METATYPES from nncf.common.graph.operator_metatypes import INPUT_NOOP_METATYPES from nncf.torch.dynamic_graph.context import TracingContext @@ -79,9 +80,11 @@ class GraphConverter: def convert(dynamic_graph: DynamicGraph, traced_parameters) -> PTNNCFGraph: module_id_vs_known_op_addrs_map: Dict[int, Set[Scope]] = defaultdict(set) for dynamic_graph_node in dynamic_graph.get_all_nodes(): - module_id_vs_known_op_addrs_map[dynamic_graph_node.calling_module_id].add( - dynamic_graph_node.op_exec_context.op_address - ) + # Skip const nodes to detect shared nodes + if dynamic_graph_node.op_exec_context.operator_name != MODEL_CONST_OP_NAME: + module_id_vs_known_op_addrs_map[dynamic_graph_node.calling_module_id].add( + dynamic_graph_node.op_exec_context.op_address + ) module_id_vs_sorted_scopes_map = { k: list(sorted([s.scope_in_model for s in v], key=str)) for k, v in module_id_vs_known_op_addrs_map.items() diff --git a/nncf/torch/graph/operator_metatypes.py b/nncf/torch/graph/operator_metatypes.py index b99bab5ebab..db09f1edab5 100644 --- a/nncf/torch/graph/operator_metatypes.py +++ b/nncf/torch/graph/operator_metatypes.py @@ -111,15 +111,33 @@ def matches( raise NotImplementedError +def _is_called_inside_nncf_module(functions_kwargs): + key = DynamicGraph.IS_CALLED_INSIDE_NNCF_MODULE + if functions_kwargs is None or key not in functions_kwargs: + return False + return functions_kwargs[key] + + class PTModuleOperatorSubtype(PTOperatorSubtype): @classmethod def matches( cls, layer_attributes: Optional[BaseLayerAttributes] = None, function_args=None, functions_kwargs=None ) -> bool: - key = DynamicGraph.IS_CALLED_INSIDE_NNCF_MODULE - if functions_kwargs is None or key not in functions_kwargs: + return _is_called_inside_nncf_module(functions_kwargs) + + +class PTModuleDepthwiseConvOperatorSubtype(PTOperatorSubtype): + @classmethod + def matches( + cls, layer_attributes: Optional[BaseLayerAttributes] = None, function_args=None, functions_kwargs=None + ) -> bool: + if not _is_called_inside_nncf_module(functions_kwargs): + return False + if not isinstance(layer_attributes, ConvolutionLayerAttributes): return False - return functions_kwargs[key] + if layer_attributes.groups == layer_attributes.in_channels and layer_attributes.in_channels > 1: + return True + return False class PTDepthwiseConvOperatorSubtype(PTOperatorSubtype): @@ -127,6 +145,8 @@ class PTDepthwiseConvOperatorSubtype(PTOperatorSubtype): def matches( cls, layer_attributes: Optional[BaseLayerAttributes] = None, function_args=None, functions_kwargs=None ) -> bool: + if _is_called_inside_nncf_module(functions_kwargs): + return False if not isinstance(layer_attributes, ConvolutionLayerAttributes): return False if layer_attributes.groups == layer_attributes.in_channels and layer_attributes.in_channels > 1: @@ -168,7 +188,7 @@ class PTNoopMetatype(PTOperatorMetatype): @PT_OPERATOR_METATYPES.register(is_subtype=True) -class PTDepthwiseConv1dSubtype(PTDepthwiseConvOperatorSubtype): +class PTModuleDepthwiseConv1dSubtype(PTModuleDepthwiseConvOperatorSubtype): name = "Conv1DOp" hw_config_name = [HWConfigOpName.DEPTHWISECONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv1d"]} @@ -183,7 +203,18 @@ class PTModuleConv1dMetatype(PTModuleOperatorSubtype): name = "Conv1DOp" hw_config_names = [HWConfigOpName.CONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv1d"]} - subtypes = [PTDepthwiseConv1dSubtype] + subtypes = [PTModuleDepthwiseConv1dSubtype] + output_channel_axis = 1 + num_expected_input_edges = 2 + weight_port_ids = [1] + bias_port_id = 2 + + +@PT_OPERATOR_METATYPES.register(is_subtype=True) +class PTDepthwiseConv1dSubtype(PTDepthwiseConvOperatorSubtype): + name = "Conv1DOp" + hw_config_name = [HWConfigOpName.DEPTHWISECONVOLUTION] + module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv1d"]} output_channel_axis = 1 num_expected_input_edges = 2 weight_port_ids = [1] @@ -195,7 +226,7 @@ class PTConv1dMetatype(PTOperatorMetatype): name = "Conv1DOp" hw_config_names = [HWConfigOpName.CONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv1d"]} - subtypes = [PTModuleConv1dMetatype] + subtypes = [PTModuleConv1dMetatype, PTDepthwiseConv1dSubtype] output_channel_axis = 1 num_expected_input_edges = 2 weight_port_ids = [1] @@ -203,7 +234,7 @@ class PTConv1dMetatype(PTOperatorMetatype): @PT_OPERATOR_METATYPES.register(is_subtype=True) -class PTDepthwiseConv2dSubtype(PTDepthwiseConvOperatorSubtype): +class PTModuleDepthwiseConv2dSubtype(PTModuleDepthwiseConvOperatorSubtype): name = "Conv2DOp" hw_config_names = [HWConfigOpName.DEPTHWISECONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv2d"]} @@ -218,7 +249,18 @@ class PTModuleConv2dMetatype(PTModuleOperatorSubtype): name = "Conv2DOp" hw_config_names = [HWConfigOpName.CONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv2d"]} - subtypes = [PTDepthwiseConv2dSubtype] + subtypes = [PTModuleDepthwiseConv2dSubtype] + output_channel_axis = 1 + num_expected_input_edges = 2 + weight_port_ids = [1] + bias_port_id = 2 + + +@PT_OPERATOR_METATYPES.register(is_subtype=True) +class PTDepthwiseConv2dSubtype(PTDepthwiseConvOperatorSubtype): + name = "Conv2DOp" + hw_config_names = [HWConfigOpName.DEPTHWISECONVOLUTION] + module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv2d"]} output_channel_axis = 1 num_expected_input_edges = 2 weight_port_ids = [1] @@ -230,7 +272,7 @@ class PTConv2dMetatype(PTOperatorMetatype): name = "Conv2DOp" hw_config_names = [HWConfigOpName.CONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv2d"]} - subtypes = [PTModuleConv2dMetatype] + subtypes = [PTModuleConv2dMetatype, PTDepthwiseConv2dSubtype] output_channel_axis = 1 num_expected_input_edges = 2 weight_port_ids = [1] @@ -238,7 +280,7 @@ class PTConv2dMetatype(PTOperatorMetatype): @PT_OPERATOR_METATYPES.register(is_subtype=True) -class PTDepthwiseConv3dSubtype(PTDepthwiseConvOperatorSubtype): +class PTModuleDepthwiseConv3dSubtype(PTModuleDepthwiseConvOperatorSubtype): name = "Conv3DOp" hw_config_names = [HWConfigOpName.DEPTHWISECONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv3d"]} @@ -253,7 +295,18 @@ class PTModuleConv3dMetatype(PTModuleOperatorSubtype): name = "Conv3DOp" hw_config_names = [HWConfigOpName.CONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv3d"]} - subtypes = [PTDepthwiseConv3dSubtype] + subtypes = [PTModuleDepthwiseConv3dSubtype] + output_channel_axis = 1 + num_expected_input_edges = 2 + weight_port_ids = [1] + bias_port_id = 2 + + +@PT_OPERATOR_METATYPES.register(is_subtype=True) +class PTDepthwiseConv3dSubtype(PTDepthwiseConvOperatorSubtype): + name = "Conv3DOp" + hw_config_names = [HWConfigOpName.DEPTHWISECONVOLUTION] + module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv3d"]} output_channel_axis = 1 num_expected_input_edges = 2 weight_port_ids = [1] @@ -265,7 +318,7 @@ class PTConv3dMetatype(PTOperatorMetatype): name = "Conv3DOp" hw_config_names = [HWConfigOpName.CONVOLUTION] module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["conv3d"]} - subtypes = [PTModuleConv3dMetatype] + subtypes = [PTModuleConv3dMetatype, PTDepthwiseConv3dSubtype] output_channel_axis = 1 num_expected_input_edges = 2 weight_port_ids = [1] @@ -434,6 +487,7 @@ class PTModuleLayerNormMetatype(PTModuleOperatorSubtype): module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["layer_norm"]} hw_config_names = [HWConfigOpName.MVN] num_expected_input_edges = 1 + weight_port_ids = [2] @PT_OPERATOR_METATYPES.register() @@ -443,6 +497,7 @@ class PTLayerNormMetatype(PTOperatorMetatype): hw_config_names = [HWConfigOpName.MVN] subtypes = [PTModuleLayerNormMetatype] num_expected_input_edges = 1 + weight_port_ids = [2] @PT_OPERATOR_METATYPES.register(is_subtype=True) @@ -450,6 +505,7 @@ class PTModuleGroupNormMetatype(PTModuleOperatorSubtype): name = "GroupNormOp" module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["group_norm"]} hw_config_names = [HWConfigOpName.MVN] + weight_port_ids = [2] @PT_OPERATOR_METATYPES.register() @@ -458,6 +514,7 @@ class PTGroupNormMetatype(PTOperatorMetatype): module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["group_norm"]} hw_config_names = [HWConfigOpName.MVN] subtypes = [PTModuleGroupNormMetatype] + weight_port_ids = [2] @PT_OPERATOR_METATYPES.register() @@ -1021,9 +1078,9 @@ def get_operator_metatypes() -> List[Type[OperatorMetatype]]: PTModuleConv1dMetatype, PTModuleConv2dMetatype, PTModuleConv3dMetatype, - PTDepthwiseConv1dSubtype, - PTDepthwiseConv2dSubtype, - PTDepthwiseConv3dSubtype, + PTModuleDepthwiseConv1dSubtype, + PTModuleDepthwiseConv2dSubtype, + PTModuleDepthwiseConv3dSubtype, PTModuleLinearMetatype, PTModuleBatchNormMetatype, PTModuleGroupNormMetatype, @@ -1039,9 +1096,9 @@ def get_operator_metatypes() -> List[Type[OperatorMetatype]]: PTModuleConv1dMetatype, PTModuleConv2dMetatype, PTModuleConv3dMetatype, - PTDepthwiseConv1dSubtype, - PTDepthwiseConv2dSubtype, - PTDepthwiseConv3dSubtype, + PTModuleDepthwiseConv1dSubtype, + PTModuleDepthwiseConv2dSubtype, + PTModuleDepthwiseConv3dSubtype, PTModuleConvTranspose1dMetatype, PTModuleConvTranspose2dMetatype, PTModuleConvTranspose3dMetatype, @@ -1050,18 +1107,6 @@ def get_operator_metatypes() -> List[Type[OperatorMetatype]]: OP_NAMES_WITH_WEIGHTS = [x for meta in OPERATORS_WITH_WEIGHTS_METATYPES for x in meta.get_all_aliases()] -# Contains the operation metatypes for which bias can be applied. -OPERATORS_WITH_BIAS_METATYPES = [ - PTModuleConv1dMetatype, - PTModuleConv2dMetatype, - PTModuleConv3dMetatype, - # TODO: Need to add Linear support (CVS-111111) -] - -OPERATORS_FUSED_METATYPES = [ - PTModuleBatchNormMetatype, -] - QUANTIZE_NODE_TYPES = ["symmetric_quantize", "asymmetric_quantize"] # These metatypes mix outputs for different samples into one axis. diff --git a/nncf/torch/graph/transformations/command_creation.py b/nncf/torch/graph/transformations/command_creation.py index 6146803ae19..a6c1ffc9a3d 100644 --- a/nncf/torch/graph/transformations/command_creation.py +++ b/nncf/torch/graph/transformations/command_creation.py @@ -53,9 +53,6 @@ def create_command_to_update_weight(node: NNCFNode, weight_value: Tensor) -> PTW def create_quantizer_insertion_command( target_point: PTTargetPoint, quantizer: BaseQuantizer ) -> Union[PTInsertionCommand, PTSharedFnInsertionCommand]: - if target_point.type is TargetType.OPERATION_WITH_WEIGHTS: - return PTInsertionCommand(target_point, quantizer, TransformationPriority.QUANTIZATION_PRIORITY) - quantizer_id = NonWeightQuantizerId(target_point.target_node_name, target_point.input_port_id) storage_key = str(quantizer_id) return PTSharedFnInsertionCommand( diff --git a/nncf/torch/graph/transformations/commands.py b/nncf/torch/graph/transformations/commands.py index b2461277a5f..49d60963d5d 100644 --- a/nncf/torch/graph/transformations/commands.py +++ b/nncf/torch/graph/transformations/commands.py @@ -179,17 +179,18 @@ def requires_graph_rebuild(self): return True -class PTModelExtractionWithFusedBiasCommand(PTCommand): +class PTModelExtractionCommand(PTCommand): """ - Extracts sequence by name with node that contain fused bias. + Extracts submodel based on the sub-model input and output names """ - def __init__(self, node_name: str): + def __init__(self, input_node_names: List[str], output_node_names: List[str]): """ :param node_name: Node name that will be extracted. """ super().__init__(TransformationType.EXTRACT) - self.node_name = node_name + self.input_node_names = input_node_names + self.output_node_names = output_node_names class PTBiasCorrectionCommand(PTTransformationCommand): diff --git a/nncf/torch/model_analyzer.py b/nncf/torch/model_analyzer.py deleted file mode 100644 index 692dc446cdd..00000000000 --- a/nncf/torch/model_analyzer.py +++ /dev/null @@ -1,98 +0,0 @@ -# Copyright (c) 2024 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 typing import Optional - -import torch - -from nncf.common.graph.graph import NNCFGraph -from nncf.common.graph.graph import NNCFNode -from nncf.torch.graph.operator_metatypes import OPERATORS_FUSED_METATYPES -from nncf.torch.graph.operator_metatypes import OPERATORS_WITH_BIAS_METATYPES -from nncf.torch.graph.operator_metatypes import QUANTIZE_NODE_TYPES -from nncf.torch.nncf_network import NNCFNetwork - - -def get_potential_fused_node(node_name: str, nncf_graph: NNCFGraph) -> Optional[NNCFNode]: - """ - Get next node that can contain fused bias in runtime. - - :param node_name: The node name. - :param nncf_graph: The NNCF graph. - :return: The node that can be fused or None. - """ - target_node = nncf_graph.get_node_by_name(node_name) - - if target_node.metatype in OPERATORS_WITH_BIAS_METATYPES: - next_nodes = nncf_graph.get_next_nodes(target_node) - for node in next_nodes: - if node.metatype in OPERATORS_FUSED_METATYPES: - return node - return None - - -def is_node_with_fused_bias(node: NNCFNode, nncf_graph: NNCFGraph) -> bool: - """ - Checks if the node has a fused bias. - - :param node: The node to check. - :param nncf_graph: The NNCF graph. - :return: Return `True` if `node` corresponds to the operation - with bias (bias is added to the output tensor of that operation), - `False` otherwise. - """ - fused_node = get_potential_fused_node(node.node_name, nncf_graph) - - return node.metatype in OPERATORS_WITH_BIAS_METATYPES and ( - node.layer_attributes.with_bias if fused_node is None else fused_node.layer_attributes.with_bias - ) - - -def get_fused_bias_value(node: NNCFNode, model: NNCFNetwork) -> Optional[torch.Tensor]: - """ - Returns the bias tensor for the node or potential fused node. - - :param node: The node that corresponds to the operation with bias. - :param model: The model that contains this operation. - :return: The bias value that is applied to the output tensor of the node's operation. - """ - nncf_graph = model.nncf.get_graph() - - target_module = model.nncf.get_containing_module(node.node_name) - fused_node = get_potential_fused_node(node.node_name, nncf_graph) - bias = target_module.bias - - if fused_node is None: - # No fused layer - return bias - - fused_module = model.nncf.get_containing_module(fused_node.node_name) - - if bias is None: - # No bias in target module, return bias from fused module - return fused_module.bias - - # Return bias value after fusing - return target_module.bias * fused_module.weight + fused_module.bias - - -def is_quantized_weights(node: NNCFNode, nncf_graph: NNCFGraph) -> bool: - """ - Check that module have fake_quantizer for weight. - - :param node: The target node. - :param nncf_graph: The NNCF graph. - :return bool: return `True` if the node is quantized. - """ - for prev_node in nncf_graph.get_previous_nodes(node): - if prev_node.node_type in QUANTIZE_NODE_TYPES: - return True - return False diff --git a/nncf/torch/model_graph_manager.py b/nncf/torch/model_graph_manager.py index ad788520705..0d7120ba07b 100644 --- a/nncf/torch/model_graph_manager.py +++ b/nncf/torch/model_graph_manager.py @@ -196,9 +196,44 @@ def get_fused_bias_value(node: NNCFNode, model: NNCFNetwork) -> Optional[torch.T """ nncf_graph = model.nncf.get_graph() fused_node = get_potential_fused_node(node.node_name, nncf_graph) - target_node_name = fused_node.node_name if fused_node else node.node_name + bias = get_const_data_on_port(node, node.metatype.bias_port_id, model) + + if fused_node is None: + return bias + + fused_bias = get_const_data_on_port(fused_node, fused_node.metatype.bias_port_id, model) + if bias is None: + return fused_bias + + fused_weight = get_const_data_on_port(fused_node, fused_node.metatype.weight_port_ids[0], model) + return bias * fused_weight + fused_bias + + +def update_fused_bias(target_node_name: str, new_bias: torch.Tensor, model: NNCFNetwork) -> None: + """ + Update bias for target module or potential fused module. + + :param target_node_name: The target node name. + :param new_bias: New bias value. + :param model: The model. + """ + nncf_graph = model.nncf.get_graph() target_node = nncf_graph.get_node_by_name(target_node_name) - return get_const_data_on_port(target_node, target_node.metatype.bias_port_id, model) + fused_node = get_potential_fused_node(target_node_name, nncf_graph) + if fused_node is None: + set_const_data_to_port_id(new_bias, target_node, target_node.metatype.bias_port_id, model) + return + + target_bias_node = get_const_node(target_node, target_node.metatype.bias_port_id, nncf_graph) + fused_bias_node = get_const_node(fused_node, fused_node.metatype.bias_port_id, nncf_graph) + fused_weight_node = get_const_node(fused_node, fused_node.metatype.weight_port_ids[0], nncf_graph) + + if target_bias_node is None: + set_const_data(new_bias, fused_bias_node, model) + return + + new_bias = new_bias - get_const_data(target_bias_node, model) * get_const_data(fused_weight_node, model) + set_const_data(new_bias, fused_bias_node, model) def get_weight_tensor_port_ids(node: NNCFNode, graph: NNCFGraph) -> List[int]: diff --git a/nncf/torch/model_transformer.py b/nncf/torch/model_transformer.py index 19c2c647b05..6bdb95fbe38 100644 --- a/nncf/torch/model_transformer.py +++ b/nncf/torch/model_transformer.py @@ -9,7 +9,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -import copy from collections import defaultdict from functools import partial from typing import Callable, Dict, List, Optional, Tuple @@ -22,15 +21,16 @@ from nncf.common.graph.model_transformer import ModelTransformer from nncf.common.graph.transformations.commands import TargetType from nncf.common.graph.transformations.commands import TransformationPriority +from nncf.torch.extractor import extract_model from nncf.torch.graph.transformations.commands import ExtraCompressionModuleType from nncf.torch.graph.transformations.commands import PTBiasCorrectionCommand from nncf.torch.graph.transformations.commands import PTInsertionCommand -from nncf.torch.graph.transformations.commands import PTModelExtractionWithFusedBiasCommand +from nncf.torch.graph.transformations.commands import PTModelExtractionCommand from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand from nncf.torch.graph.transformations.commands import PTTargetPoint from nncf.torch.graph.transformations.commands import PTWeightUpdateCommand from nncf.torch.graph.transformations.layout import PTTransformationLayout -from nncf.torch.model_analyzer import get_potential_fused_node +from nncf.torch.model_graph_manager import update_fused_bias from nncf.torch.module_operations import UpdateWeight from nncf.torch.nncf_network import NNCFNetwork from nncf.torch.nncf_network import PTInsertionPoint @@ -53,7 +53,7 @@ def __init__(self, model: NNCFNetwork): device = get_model_device(model) self._command_transformation_ordered_pairs = [ - (PTModelExtractionWithFusedBiasCommand, self._apply_extraction_with_fused_bias_transformations), + (PTModelExtractionCommand, self._apply_extraction_transformations), (PTInsertionCommand, partial(self._apply_insertion_transformations, device=device)), (PTSharedFnInsertionCommand, partial(self._apply_shared_nodes_insertion, device=device)), (PTBiasCorrectionCommand, self._apply_bias_correction_transformations), @@ -193,18 +193,18 @@ def _apply_shared_node_insertion_with_compression_type( return PTModelTransformer._apply_insertion_transformations(model, insertion_commands, device) @staticmethod - def _apply_extraction_with_fused_bias_transformations( - model: NNCFNetwork, transformations: List[PTModelExtractionWithFusedBiasCommand] + def _apply_extraction_transformations( + model: NNCFNetwork, transformations: List[PTModelExtractionCommand] ) -> nn.Sequential: """ - Extracts copy of sub-modules from the original base on node name and potential fused nodes. + Extracts copy of sub-modules. :param model: Model to apply transformations. :param transformation: Model extraction transformation. :return: Extracted sub-modules. """ transformation = transformations[-1] - return extraction_potential_fused_modules(transformation.node_name, model) + return extract_model(model, transformation.input_node_names, transformation.output_node_names) @staticmethod def _apply_bias_correction_transformations( @@ -241,29 +241,6 @@ def _apply_weights_update_transformations( return model -def update_fused_bias(target_node_name: str, new_bias: Tensor, model: NNCFNetwork) -> None: - """ - Update bias for target module or potential fused module. - - :param target_node_name: The target node name. - :param new_bias: New bias value. - :param model: The model. - """ - nncf_graph = model.nncf.get_graph() - fused_node = get_potential_fused_node(target_node_name, nncf_graph) - if fused_node is None: - update_parameter(target_node_name, "bias", new_bias, model) - return - target_module = model.nncf.get_containing_module(target_node_name) - fused_module = model.nncf.get_containing_module(fused_node.node_name) - - if target_module.bias is None: - update_parameter(fused_node.node_name, "bias", new_bias, model) - return - new_bias = new_bias - target_module.bias * fused_module.weight - update_parameter(fused_node.node_name, "bias", new_bias, model) - - def update_parameter(target_node_name: str, parameter_name: str, new_value: Tensor, model: NNCFNetwork) -> None: """ Update parameter for target module. @@ -276,23 +253,3 @@ def update_parameter(target_node_name: str, parameter_name: str, new_value: Tens module = model.nncf.get_containing_module(target_node_name) parameter: Parameter = getattr(module, parameter_name) parameter.data = new_value - - -def extraction_potential_fused_modules(node_name: str, model: NNCFNetwork) -> nn.Sequential: - """ - Return Sequential from the copy of module by node_name and potential fused node if exists. - - :param node_name: The node name. - :param model: The model. - :return nn.Sequential: Copy of the modules. - """ - extracted_node_names = [node_name] - nncf_graph = model.nncf.get_graph() - fused_node = get_potential_fused_node(node_name, nncf_graph) - if fused_node: - extracted_node_names.append(fused_node.node_name) - - extracted_modules = [ - copy.deepcopy(model.nncf.get_containing_module(node_name)) for node_name in extracted_node_names - ] - return nn.Sequential(*extracted_modules) diff --git a/nncf/torch/pruning/filter_pruning/algo.py b/nncf/torch/pruning/filter_pruning/algo.py index e42d0c3d076..1f48e02d67e 100644 --- a/nncf/torch/pruning/filter_pruning/algo.py +++ b/nncf/torch/pruning/filter_pruning/algo.py @@ -47,15 +47,15 @@ from nncf.config.extractors import extract_bn_adaptation_init_params from nncf.torch.algo_selector import PT_COMPRESSION_ALGORITHMS from nncf.torch.compression_method_api import PTCompressionAlgorithmController -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv1dSubtype -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv3dSubtype from nncf.torch.graph.operator_metatypes import PTModuleConv1dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConv3dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConvTranspose1dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConvTranspose2dMetatype from nncf.torch.graph.operator_metatypes import PTModuleConvTranspose3dMetatype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv1dSubtype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv3dSubtype from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype from nncf.torch.layers import NNCF_PRUNING_MODULES_DICT from nncf.torch.nncf_network import NNCFNetwork @@ -80,11 +80,11 @@ GENERAL_CONV_LAYER_METATYPES = [ PTModuleConv1dMetatype, - PTDepthwiseConv1dSubtype, + PTModuleDepthwiseConv1dSubtype, PTModuleConv2dMetatype, - PTDepthwiseConv2dSubtype, + PTModuleDepthwiseConv2dSubtype, PTModuleConv3dMetatype, - PTDepthwiseConv3dSubtype, + PTModuleDepthwiseConv3dSubtype, PTModuleConvTranspose1dMetatype, PTModuleConvTranspose2dMetatype, PTModuleConvTranspose3dMetatype, diff --git a/nncf/torch/quantization/algo.py b/nncf/torch/quantization/algo.py index 1cbeeac4f69..d6bfa0b137c 100644 --- a/nncf/torch/quantization/algo.py +++ b/nncf/torch/quantization/algo.py @@ -81,8 +81,8 @@ from nncf.torch.graph.graph import PTNNCFGraph from nncf.torch.graph.operator_metatypes import UNIFICATION_PRODUCING_METATYPES from nncf.torch.graph.operator_metatypes import PTCatMetatype -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype from nncf.torch.graph.transformations.commands import ExtraCompressionModuleType from nncf.torch.graph.transformations.commands import PTInsertionCommand from nncf.torch.graph.transformations.commands import PTTargetPoint @@ -829,7 +829,7 @@ def _get_adjust_padding_args( if weight_bitwidth: is_applicable = False target_node = target_model_graph.get_node_by_name(op_node_name) - if target_node.metatype in [PTModuleConv2dMetatype, PTDepthwiseConv2dSubtype]: + if target_node.metatype in [PTModuleConv2dMetatype, PTModuleDepthwiseConv2dSubtype]: layer_attrs = target_node.layer_attributes assert isinstance(layer_attrs, ConvolutionLayerAttributes) padding_values = set(layer_attrs.padding_values) diff --git a/nncf/torch/quantization/default_quantization.py b/nncf/torch/quantization/default_quantization.py index 5a26ce0ed75..53057d8b79d 100644 --- a/nncf/torch/quantization/default_quantization.py +++ b/nncf/torch/quantization/default_quantization.py @@ -29,6 +29,8 @@ operator_metatypes.PTModuleConvTranspose3dMetatype, operator_metatypes.PTDepthwiseConv2dSubtype, operator_metatypes.PTDepthwiseConv3dSubtype, + operator_metatypes.PTModuleDepthwiseConv2dSubtype, + operator_metatypes.PTModuleDepthwiseConv3dSubtype, operator_metatypes.PTLinearMetatype, operator_metatypes.PTModuleLinearMetatype, operator_metatypes.PTLayerNormMetatype, diff --git a/nncf/torch/quantization/quantize_model.py b/nncf/torch/quantization/quantize_model.py index 48f3ddefae2..57764163e59 100644 --- a/nncf/torch/quantization/quantize_model.py +++ b/nncf/torch/quantization/quantize_model.py @@ -59,7 +59,7 @@ def quantize_impl( copied_model = deepcopy(model) example_input = next(iter(calibration_dataset.get_inference_data())) - nncf_network = wrap_model(copied_model.eval(), example_input) + nncf_network = wrap_model(copied_model.eval(), example_input, trace_parameters=True) quantization_algorithm = PostTrainingQuantization( preset=preset, diff --git a/nncf/torch/quantization/strip.py b/nncf/torch/quantization/strip.py index 76cbeac741d..beeb66395d7 100644 --- a/nncf/torch/quantization/strip.py +++ b/nncf/torch/quantization/strip.py @@ -139,6 +139,9 @@ def remove_disabled_quantizers(model: NNCFNetwork) -> NNCFNetwork: if isinstance(op, BaseQuantizer) and not op.is_enabled_quantization(): external_quantizers.pop(key) + if not model.nncf.replace_modules: + return model + for node in model.nncf.get_original_graph().get_all_nodes(): if node.node_type in ["nncf_model_input", "nncf_model_output"]: continue diff --git a/tests/post_training/pipelines/image_classification_timm.py b/tests/post_training/pipelines/image_classification_timm.py index 5cda1d04e6d..f53643b6cc3 100644 --- a/tests/post_training/pipelines/image_classification_timm.py +++ b/tests/post_training/pipelines/image_classification_timm.py @@ -24,9 +24,6 @@ import nncf from nncf.common.logging.track_progress import track -from nncf.experimental.torch.replace_custom_modules.timm_custom_modules import ( - replace_timm_custom_modules_with_torch_native, -) from tests.post_training.pipelines.base import DEFAULT_VAL_THREADS from tests.post_training.pipelines.base import OV_BACKENDS from tests.post_training.pipelines.base import PT_BACKENDS @@ -43,7 +40,6 @@ class ImageClassificationTimm(PTQTestPipeline): def prepare_model(self) -> None: timm_model = timm.create_model(self.model_id, num_classes=1000, in_chans=3, pretrained=True, checkpoint_path="") timm_model.eval() - timm_model = replace_timm_custom_modules_with_torch_native(timm_model) self.model_cfg = timm_model.default_cfg self.input_size = [self.batch_size] + list(timm_model.default_cfg["input_size"]) self.dummy_tensor = torch.rand(self.input_size) diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/alexnet.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/alexnet.dot index a53329f3f99..9a1af32de6b 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/alexnet.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/alexnet.dot @@ -1,79 +1,111 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 AlexNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 AlexNet/Sequential[features]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 AlexNet/Sequential[features]/ReLU[1]/relu__0" [id=4, type=relu_]; -"5 AlexNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" [id=5, type=symmetric_quantize]; -"6 AlexNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" [id=6, type=max_pool2d]; -"7 AlexNet/Sequential[features]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 AlexNet/Sequential[features]/NNCFConv2d[3]/conv2d_0" [id=8, type=conv2d]; -"9 AlexNet/Sequential[features]/ReLU[4]/relu__0" [id=9, type=relu_]; -"10 AlexNet/Sequential[features]/ReLU[4]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; -"11 AlexNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" [id=11, type=max_pool2d]; -"12 AlexNet/Sequential[features]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=12, type=symmetric_quantize]; -"13 AlexNet/Sequential[features]/NNCFConv2d[6]/conv2d_0" [id=13, type=conv2d]; -"14 AlexNet/Sequential[features]/ReLU[7]/relu__0" [id=14, type=relu_]; -"15 AlexNet/Sequential[features]/ReLU[7]/SymmetricQuantizer/symmetric_quantize_0" [id=15, type=symmetric_quantize]; -"16 AlexNet/Sequential[features]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 AlexNet/Sequential[features]/NNCFConv2d[8]/conv2d_0" [id=17, type=conv2d]; -"18 AlexNet/Sequential[features]/ReLU[9]/relu__0" [id=18, type=relu_]; -"19 AlexNet/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; -"20 AlexNet/Sequential[features]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 AlexNet/Sequential[features]/NNCFConv2d[10]/conv2d_0" [id=21, type=conv2d]; -"22 AlexNet/Sequential[features]/ReLU[11]/relu__0" [id=22, type=relu_]; -"23 AlexNet/Sequential[features]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; -"24 AlexNet/Sequential[features]/MaxPool2d[12]/max_pool2d_0" [id=24, type=max_pool2d]; -"25 AlexNet/view_0" [id=25, type=view]; -"26 AlexNet/Sequential[classifier]/Dropout[0]/dropout_0" [id=26, type=dropout]; -"27 AlexNet/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=27, type=symmetric_quantize]; -"28 AlexNet/Sequential[classifier]/NNCFLinear[1]/linear_0" [id=28, type=linear]; -"29 AlexNet/Sequential[classifier]/ReLU[2]/relu__0" [id=29, type=relu_]; -"30 AlexNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; -"31 AlexNet/Sequential[classifier]/Dropout[3]/dropout_0" [id=31, type=dropout]; -"32 AlexNet/Sequential[classifier]/NNCFLinear[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=32, type=symmetric_quantize]; -"33 AlexNet/Sequential[classifier]/NNCFLinear[4]/linear_0" [id=33, type=linear]; -"34 AlexNet/Sequential[classifier]/ReLU[5]/relu__0" [id=34, type=relu_]; -"35 AlexNet/Sequential[classifier]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=35, type=symmetric_quantize]; -"36 AlexNet/Sequential[classifier]/NNCFLinear[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=36, type=symmetric_quantize]; -"37 AlexNet/Sequential[classifier]/NNCFLinear[6]/linear_0" [id=37, type=linear]; -"38 /nncf_model_output_0" [id=38, type=nncf_model_output]; +"2 features.0.weight" [id=2, type=nncf_model_const]; +"3 features.0.bias" [id=3, type=nncf_model_const]; +"4 AlexNet/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 AlexNet/Sequential[features]/Conv2d[0]/conv2d_0" [id=5, type=conv2d]; +"6 AlexNet/Sequential[features]/ReLU[1]/relu__0" [id=6, type=relu_]; +"7 AlexNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 AlexNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" [id=8, type=max_pool2d]; +"9 features.3.weight" [id=9, type=nncf_model_const]; +"10 features.3.bias" [id=10, type=nncf_model_const]; +"11 AlexNet/Sequential[features]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 AlexNet/Sequential[features]/Conv2d[3]/conv2d_0" [id=12, type=conv2d]; +"13 AlexNet/Sequential[features]/ReLU[4]/relu__0" [id=13, type=relu_]; +"14 AlexNet/Sequential[features]/ReLU[4]/SymmetricQuantizer/symmetric_quantize_0" [id=14, type=symmetric_quantize]; +"15 AlexNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" [id=15, type=max_pool2d]; +"16 features.6.weight" [id=16, type=nncf_model_const]; +"17 features.6.bias" [id=17, type=nncf_model_const]; +"18 AlexNet/Sequential[features]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=18, type=symmetric_quantize]; +"19 AlexNet/Sequential[features]/Conv2d[6]/conv2d_0" [id=19, type=conv2d]; +"20 AlexNet/Sequential[features]/ReLU[7]/relu__0" [id=20, type=relu_]; +"21 AlexNet/Sequential[features]/ReLU[7]/SymmetricQuantizer/symmetric_quantize_0" [id=21, type=symmetric_quantize]; +"22 features.8.weight" [id=22, type=nncf_model_const]; +"23 features.8.bias" [id=23, type=nncf_model_const]; +"24 AlexNet/Sequential[features]/Conv2d[8]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; +"25 AlexNet/Sequential[features]/Conv2d[8]/conv2d_0" [id=25, type=conv2d]; +"26 AlexNet/Sequential[features]/ReLU[9]/relu__0" [id=26, type=relu_]; +"27 AlexNet/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" [id=27, type=symmetric_quantize]; +"28 features.10.weight" [id=28, type=nncf_model_const]; +"29 features.10.bias" [id=29, type=nncf_model_const]; +"30 AlexNet/Sequential[features]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 AlexNet/Sequential[features]/Conv2d[10]/conv2d_0" [id=31, type=conv2d]; +"32 AlexNet/Sequential[features]/ReLU[11]/relu__0" [id=32, type=relu_]; +"33 AlexNet/Sequential[features]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; +"34 AlexNet/Sequential[features]/MaxPool2d[12]/max_pool2d_0" [id=34, type=max_pool2d]; +"35 AlexNet/view_0" [id=35, type=view]; +"36 AlexNet/Sequential[classifier]/Dropout[0]/dropout_0" [id=36, type=dropout]; +"37 classifier.1.weight" [id=37, type=nncf_model_const]; +"38 classifier.1.bias" [id=38, type=nncf_model_const]; +"39 AlexNet/Sequential[classifier]/Linear[1]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 AlexNet/Sequential[classifier]/Linear[1]/linear_0" [id=40, type=linear]; +"41 AlexNet/Sequential[classifier]/ReLU[2]/relu__0" [id=41, type=relu_]; +"42 AlexNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 AlexNet/Sequential[classifier]/Dropout[3]/dropout_0" [id=43, type=dropout]; +"44 classifier.4.weight" [id=44, type=nncf_model_const]; +"45 classifier.4.bias" [id=45, type=nncf_model_const]; +"46 AlexNet/Sequential[classifier]/Linear[4]/SymmetricQuantizer/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 AlexNet/Sequential[classifier]/Linear[4]/linear_0" [id=47, type=linear]; +"48 AlexNet/Sequential[classifier]/ReLU[5]/relu__0" [id=48, type=relu_]; +"49 AlexNet/Sequential[classifier]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=49, type=symmetric_quantize]; +"50 classifier.6.weight" [id=50, type=nncf_model_const]; +"51 classifier.6.bias" [id=51, type=nncf_model_const]; +"52 AlexNet/Sequential[classifier]/Linear[6]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; +"53 AlexNet/Sequential[classifier]/Linear[6]/linear_0" [id=53, type=linear]; +"54 /nncf_model_output_0" [id=54, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 AlexNet/Sequential[features]/NNCFConv2d[0]/conv2d_0"; -"2 AlexNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 AlexNet/Sequential[features]/NNCFConv2d[0]/conv2d_0"; -"3 AlexNet/Sequential[features]/NNCFConv2d[0]/conv2d_0" -> "4 AlexNet/Sequential[features]/ReLU[1]/relu__0"; -"4 AlexNet/Sequential[features]/ReLU[1]/relu__0" -> "5 AlexNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0"; -"5 AlexNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" -> "6 AlexNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0"; -"6 AlexNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" -> "8 AlexNet/Sequential[features]/NNCFConv2d[3]/conv2d_0"; -"7 AlexNet/Sequential[features]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 AlexNet/Sequential[features]/NNCFConv2d[3]/conv2d_0"; -"8 AlexNet/Sequential[features]/NNCFConv2d[3]/conv2d_0" -> "9 AlexNet/Sequential[features]/ReLU[4]/relu__0"; -"9 AlexNet/Sequential[features]/ReLU[4]/relu__0" -> "10 AlexNet/Sequential[features]/ReLU[4]/SymmetricQuantizer/symmetric_quantize_0"; -"10 AlexNet/Sequential[features]/ReLU[4]/SymmetricQuantizer/symmetric_quantize_0" -> "11 AlexNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0"; -"11 AlexNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" -> "13 AlexNet/Sequential[features]/NNCFConv2d[6]/conv2d_0"; -"12 AlexNet/Sequential[features]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "13 AlexNet/Sequential[features]/NNCFConv2d[6]/conv2d_0"; -"13 AlexNet/Sequential[features]/NNCFConv2d[6]/conv2d_0" -> "14 AlexNet/Sequential[features]/ReLU[7]/relu__0"; -"14 AlexNet/Sequential[features]/ReLU[7]/relu__0" -> "15 AlexNet/Sequential[features]/ReLU[7]/SymmetricQuantizer/symmetric_quantize_0"; -"15 AlexNet/Sequential[features]/ReLU[7]/SymmetricQuantizer/symmetric_quantize_0" -> "17 AlexNet/Sequential[features]/NNCFConv2d[8]/conv2d_0"; -"16 AlexNet/Sequential[features]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "17 AlexNet/Sequential[features]/NNCFConv2d[8]/conv2d_0"; -"17 AlexNet/Sequential[features]/NNCFConv2d[8]/conv2d_0" -> "18 AlexNet/Sequential[features]/ReLU[9]/relu__0"; -"18 AlexNet/Sequential[features]/ReLU[9]/relu__0" -> "19 AlexNet/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0"; -"19 AlexNet/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" -> "21 AlexNet/Sequential[features]/NNCFConv2d[10]/conv2d_0"; -"20 AlexNet/Sequential[features]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 AlexNet/Sequential[features]/NNCFConv2d[10]/conv2d_0"; -"21 AlexNet/Sequential[features]/NNCFConv2d[10]/conv2d_0" -> "22 AlexNet/Sequential[features]/ReLU[11]/relu__0"; -"22 AlexNet/Sequential[features]/ReLU[11]/relu__0" -> "23 AlexNet/Sequential[features]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0"; -"23 AlexNet/Sequential[features]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "24 AlexNet/Sequential[features]/MaxPool2d[12]/max_pool2d_0"; -"24 AlexNet/Sequential[features]/MaxPool2d[12]/max_pool2d_0" -> "25 AlexNet/view_0"; -"25 AlexNet/view_0" -> "26 AlexNet/Sequential[classifier]/Dropout[0]/dropout_0"; -"26 AlexNet/Sequential[classifier]/Dropout[0]/dropout_0" -> "28 AlexNet/Sequential[classifier]/NNCFLinear[1]/linear_0"; -"27 AlexNet/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "28 AlexNet/Sequential[classifier]/NNCFLinear[1]/linear_0"; -"28 AlexNet/Sequential[classifier]/NNCFLinear[1]/linear_0" -> "29 AlexNet/Sequential[classifier]/ReLU[2]/relu__0"; -"29 AlexNet/Sequential[classifier]/ReLU[2]/relu__0" -> "30 AlexNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"30 AlexNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "31 AlexNet/Sequential[classifier]/Dropout[3]/dropout_0"; -"31 AlexNet/Sequential[classifier]/Dropout[3]/dropout_0" -> "33 AlexNet/Sequential[classifier]/NNCFLinear[4]/linear_0"; -"32 AlexNet/Sequential[classifier]/NNCFLinear[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "33 AlexNet/Sequential[classifier]/NNCFLinear[4]/linear_0"; -"33 AlexNet/Sequential[classifier]/NNCFLinear[4]/linear_0" -> "34 AlexNet/Sequential[classifier]/ReLU[5]/relu__0"; -"34 AlexNet/Sequential[classifier]/ReLU[5]/relu__0" -> "35 AlexNet/Sequential[classifier]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"35 AlexNet/Sequential[classifier]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "37 AlexNet/Sequential[classifier]/NNCFLinear[6]/linear_0"; -"36 AlexNet/Sequential[classifier]/NNCFLinear[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "37 AlexNet/Sequential[classifier]/NNCFLinear[6]/linear_0"; -"37 AlexNet/Sequential[classifier]/NNCFLinear[6]/linear_0" -> "38 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 AlexNet/Sequential[features]/Conv2d[0]/conv2d_0"; +"2 features.0.weight" -> "4 AlexNet/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 features.0.bias" -> "5 AlexNet/Sequential[features]/Conv2d[0]/conv2d_0"; +"4 AlexNet/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "5 AlexNet/Sequential[features]/Conv2d[0]/conv2d_0"; +"5 AlexNet/Sequential[features]/Conv2d[0]/conv2d_0" -> "6 AlexNet/Sequential[features]/ReLU[1]/relu__0"; +"6 AlexNet/Sequential[features]/ReLU[1]/relu__0" -> "7 AlexNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0"; +"7 AlexNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" -> "8 AlexNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0"; +"8 AlexNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" -> "12 AlexNet/Sequential[features]/Conv2d[3]/conv2d_0"; +"9 features.3.weight" -> "11 AlexNet/Sequential[features]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"10 features.3.bias" -> "12 AlexNet/Sequential[features]/Conv2d[3]/conv2d_0"; +"11 AlexNet/Sequential[features]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "12 AlexNet/Sequential[features]/Conv2d[3]/conv2d_0"; +"12 AlexNet/Sequential[features]/Conv2d[3]/conv2d_0" -> "13 AlexNet/Sequential[features]/ReLU[4]/relu__0"; +"13 AlexNet/Sequential[features]/ReLU[4]/relu__0" -> "14 AlexNet/Sequential[features]/ReLU[4]/SymmetricQuantizer/symmetric_quantize_0"; +"14 AlexNet/Sequential[features]/ReLU[4]/SymmetricQuantizer/symmetric_quantize_0" -> "15 AlexNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0"; +"15 AlexNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" -> "19 AlexNet/Sequential[features]/Conv2d[6]/conv2d_0"; +"16 features.6.weight" -> "18 AlexNet/Sequential[features]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"17 features.6.bias" -> "19 AlexNet/Sequential[features]/Conv2d[6]/conv2d_0"; +"18 AlexNet/Sequential[features]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "19 AlexNet/Sequential[features]/Conv2d[6]/conv2d_0"; +"19 AlexNet/Sequential[features]/Conv2d[6]/conv2d_0" -> "20 AlexNet/Sequential[features]/ReLU[7]/relu__0"; +"20 AlexNet/Sequential[features]/ReLU[7]/relu__0" -> "21 AlexNet/Sequential[features]/ReLU[7]/SymmetricQuantizer/symmetric_quantize_0"; +"21 AlexNet/Sequential[features]/ReLU[7]/SymmetricQuantizer/symmetric_quantize_0" -> "25 AlexNet/Sequential[features]/Conv2d[8]/conv2d_0"; +"22 features.8.weight" -> "24 AlexNet/Sequential[features]/Conv2d[8]/SymmetricQuantizer/symmetric_quantize_0"; +"23 features.8.bias" -> "25 AlexNet/Sequential[features]/Conv2d[8]/conv2d_0"; +"24 AlexNet/Sequential[features]/Conv2d[8]/SymmetricQuantizer/symmetric_quantize_0" -> "25 AlexNet/Sequential[features]/Conv2d[8]/conv2d_0"; +"25 AlexNet/Sequential[features]/Conv2d[8]/conv2d_0" -> "26 AlexNet/Sequential[features]/ReLU[9]/relu__0"; +"26 AlexNet/Sequential[features]/ReLU[9]/relu__0" -> "27 AlexNet/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0"; +"27 AlexNet/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" -> "31 AlexNet/Sequential[features]/Conv2d[10]/conv2d_0"; +"28 features.10.weight" -> "30 AlexNet/Sequential[features]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0"; +"29 features.10.bias" -> "31 AlexNet/Sequential[features]/Conv2d[10]/conv2d_0"; +"30 AlexNet/Sequential[features]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0" -> "31 AlexNet/Sequential[features]/Conv2d[10]/conv2d_0"; +"31 AlexNet/Sequential[features]/Conv2d[10]/conv2d_0" -> "32 AlexNet/Sequential[features]/ReLU[11]/relu__0"; +"32 AlexNet/Sequential[features]/ReLU[11]/relu__0" -> "33 AlexNet/Sequential[features]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0"; +"33 AlexNet/Sequential[features]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "34 AlexNet/Sequential[features]/MaxPool2d[12]/max_pool2d_0"; +"34 AlexNet/Sequential[features]/MaxPool2d[12]/max_pool2d_0" -> "35 AlexNet/view_0"; +"35 AlexNet/view_0" -> "36 AlexNet/Sequential[classifier]/Dropout[0]/dropout_0"; +"36 AlexNet/Sequential[classifier]/Dropout[0]/dropout_0" -> "40 AlexNet/Sequential[classifier]/Linear[1]/linear_0"; +"37 classifier.1.weight" -> "39 AlexNet/Sequential[classifier]/Linear[1]/SymmetricQuantizer/symmetric_quantize_0"; +"38 classifier.1.bias" -> "40 AlexNet/Sequential[classifier]/Linear[1]/linear_0"; +"39 AlexNet/Sequential[classifier]/Linear[1]/SymmetricQuantizer/symmetric_quantize_0" -> "40 AlexNet/Sequential[classifier]/Linear[1]/linear_0"; +"40 AlexNet/Sequential[classifier]/Linear[1]/linear_0" -> "41 AlexNet/Sequential[classifier]/ReLU[2]/relu__0"; +"41 AlexNet/Sequential[classifier]/ReLU[2]/relu__0" -> "42 AlexNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"42 AlexNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "43 AlexNet/Sequential[classifier]/Dropout[3]/dropout_0"; +"43 AlexNet/Sequential[classifier]/Dropout[3]/dropout_0" -> "47 AlexNet/Sequential[classifier]/Linear[4]/linear_0"; +"44 classifier.4.weight" -> "46 AlexNet/Sequential[classifier]/Linear[4]/SymmetricQuantizer/symmetric_quantize_0"; +"45 classifier.4.bias" -> "47 AlexNet/Sequential[classifier]/Linear[4]/linear_0"; +"46 AlexNet/Sequential[classifier]/Linear[4]/SymmetricQuantizer/symmetric_quantize_0" -> "47 AlexNet/Sequential[classifier]/Linear[4]/linear_0"; +"47 AlexNet/Sequential[classifier]/Linear[4]/linear_0" -> "48 AlexNet/Sequential[classifier]/ReLU[5]/relu__0"; +"48 AlexNet/Sequential[classifier]/ReLU[5]/relu__0" -> "49 AlexNet/Sequential[classifier]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"49 AlexNet/Sequential[classifier]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "53 AlexNet/Sequential[classifier]/Linear[6]/linear_0"; +"50 classifier.6.weight" -> "52 AlexNet/Sequential[classifier]/Linear[6]/SymmetricQuantizer/symmetric_quantize_0"; +"51 classifier.6.bias" -> "53 AlexNet/Sequential[classifier]/Linear[6]/linear_0"; +"52 AlexNet/Sequential[classifier]/Linear[6]/SymmetricQuantizer/symmetric_quantize_0" -> "53 AlexNet/Sequential[classifier]/Linear[6]/linear_0"; +"53 AlexNet/Sequential[classifier]/Linear[6]/linear_0" -> "54 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/densenet121.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/densenet121.dot index 7e5120d19a4..c0bbe1e31d2 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/densenet121.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/densenet121.dot @@ -1,1527 +1,2251 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 DenseNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 DenseNet/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; -"4 DenseNet/NNCFConv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; -"5 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=5, type=batch_norm]; -"6 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_0" [id=6, type=relu]; -"7 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=8, type=symmetric_quantize]; -"9 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=9, type=conv2d]; -"10 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=10, type=batch_norm]; -"11 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_1" [id=11, type=relu]; -"12 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=12, type=symmetric_quantize]; -"13 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; -"14 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=14, type=conv2d]; -"15 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=15, type=symmetric_quantize]; -"16 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0" [id=16, type=cat]; -"17 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=17, type=batch_norm]; -"18 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_0" [id=18, type=relu]; -"19 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; -"20 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=21, type=conv2d]; -"22 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=22, type=batch_norm]; -"23 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_1" [id=23, type=relu]; -"24 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=24, type=symmetric_quantize]; -"25 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=26, type=conv2d]; -"27 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=27, type=symmetric_quantize]; -"28 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0" [id=28, type=cat]; -"29 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=29, type=batch_norm]; -"30 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_0" [id=30, type=relu]; -"31 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; -"32 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=32, type=symmetric_quantize]; -"33 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=33, type=conv2d]; -"34 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=34, type=batch_norm]; -"35 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_1" [id=35, type=relu]; -"36 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=36, type=symmetric_quantize]; -"37 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=37, type=symmetric_quantize]; -"38 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=38, type=conv2d]; -"39 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; -"40 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0" [id=40, type=cat]; -"41 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=41, type=batch_norm]; -"42 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_0" [id=42, type=relu]; -"43 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=43, type=symmetric_quantize]; -"44 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=45, type=conv2d]; -"46 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=46, type=batch_norm]; -"47 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_1" [id=47, type=relu]; -"48 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=48, type=symmetric_quantize]; -"49 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=49, type=symmetric_quantize]; -"50 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=50, type=conv2d]; -"51 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=51, type=symmetric_quantize]; -"52 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0" [id=52, type=cat]; -"53 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=53, type=batch_norm]; -"54 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_0" [id=54, type=relu]; -"55 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; -"56 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; -"57 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=57, type=conv2d]; -"58 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=58, type=batch_norm]; -"59 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_1" [id=59, type=relu]; -"60 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=60, type=symmetric_quantize]; -"61 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; -"62 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=62, type=conv2d]; -"63 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; -"64 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0" [id=64, type=cat]; -"65 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=65, type=batch_norm]; -"66 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_0" [id=66, type=relu]; -"67 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=67, type=symmetric_quantize]; -"68 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=68, type=symmetric_quantize]; -"69 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=69, type=conv2d]; -"70 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=70, type=batch_norm]; -"71 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_1" [id=71, type=relu]; -"72 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=72, type=symmetric_quantize]; -"73 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=74, type=conv2d]; -"75 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0" [id=76, type=cat]; -"77 DenseNet/Transition[trans1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=77, type=batch_norm]; -"78 DenseNet/Transition[trans1]/relu_0" [id=78, type=relu]; -"79 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; -"80 DenseNet/Transition[trans1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 DenseNet/Transition[trans1]/NNCFConv2d[conv]/conv2d_0" [id=81, type=conv2d]; -"82 DenseNet/Transition[trans1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=82, type=symmetric_quantize]; -"83 DenseNet/Transition[trans1]/avg_pool2d_0" [id=83, type=avg_pool2d]; -"84 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1" [id=84, type=symmetric_quantize]; -"85 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=85, type=batch_norm]; -"86 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_0" [id=86, type=relu]; -"87 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=87, type=symmetric_quantize]; -"88 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=88, type=symmetric_quantize]; -"89 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=89, type=conv2d]; -"90 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=90, type=batch_norm]; -"91 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_1" [id=91, type=relu]; -"92 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=92, type=symmetric_quantize]; -"93 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=93, type=symmetric_quantize]; -"94 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=94, type=conv2d]; -"95 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=95, type=symmetric_quantize]; -"96 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0" [id=96, type=cat]; -"97 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=97, type=batch_norm]; -"98 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_0" [id=98, type=relu]; -"99 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=99, type=symmetric_quantize]; -"100 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=101, type=conv2d]; -"102 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=102, type=batch_norm]; -"103 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_1" [id=103, type=relu]; -"104 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=104, type=symmetric_quantize]; -"105 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=105, type=symmetric_quantize]; -"106 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=106, type=conv2d]; -"107 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=107, type=symmetric_quantize]; -"108 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0" [id=108, type=cat]; -"109 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=109, type=batch_norm]; -"110 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_0" [id=110, type=relu]; -"111 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=112, type=symmetric_quantize]; -"113 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=113, type=conv2d]; -"114 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=114, type=batch_norm]; -"115 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_1" [id=115, type=relu]; -"116 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=116, type=symmetric_quantize]; -"117 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=118, type=conv2d]; -"119 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=119, type=symmetric_quantize]; -"120 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0" [id=120, type=cat]; -"121 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=121, type=batch_norm]; -"122 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_0" [id=122, type=relu]; -"123 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; -"124 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=124, type=symmetric_quantize]; -"125 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=125, type=conv2d]; -"126 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=126, type=batch_norm]; -"127 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_1" [id=127, type=relu]; -"128 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=128, type=symmetric_quantize]; -"129 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=129, type=symmetric_quantize]; -"130 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=130, type=conv2d]; -"131 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; -"132 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0" [id=132, type=cat]; -"133 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=133, type=batch_norm]; -"134 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_0" [id=134, type=relu]; -"135 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=135, type=symmetric_quantize]; -"136 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=136, type=symmetric_quantize]; -"137 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=137, type=conv2d]; -"138 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=138, type=batch_norm]; -"139 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_1" [id=139, type=relu]; -"140 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=140, type=symmetric_quantize]; -"141 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=141, type=symmetric_quantize]; -"142 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=142, type=conv2d]; -"143 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=143, type=symmetric_quantize]; -"144 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0" [id=144, type=cat]; -"145 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=145, type=batch_norm]; -"146 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_0" [id=146, type=relu]; -"147 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; -"148 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=149, type=conv2d]; -"150 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=150, type=batch_norm]; -"151 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_1" [id=151, type=relu]; -"152 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=152, type=symmetric_quantize]; -"153 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=153, type=symmetric_quantize]; -"154 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=154, type=conv2d]; -"155 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; -"156 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0" [id=156, type=cat]; -"157 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=157, type=batch_norm]; -"158 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_0" [id=158, type=relu]; -"159 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" [id=159, type=symmetric_quantize]; -"160 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=160, type=symmetric_quantize]; -"161 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0" [id=161, type=conv2d]; -"162 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=162, type=batch_norm]; -"163 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_1" [id=163, type=relu]; -"164 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" [id=164, type=symmetric_quantize]; -"165 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=165, type=symmetric_quantize]; -"166 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0" [id=166, type=conv2d]; -"167 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; -"168 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0" [id=168, type=cat]; -"169 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=169, type=batch_norm]; -"170 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_0" [id=170, type=relu]; -"171 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" [id=171, type=symmetric_quantize]; -"172 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=172, type=symmetric_quantize]; -"173 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0" [id=173, type=conv2d]; -"174 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=174, type=batch_norm]; -"175 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_1" [id=175, type=relu]; -"176 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" [id=176, type=symmetric_quantize]; -"177 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=177, type=symmetric_quantize]; -"178 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0" [id=178, type=conv2d]; -"179 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=179, type=symmetric_quantize]; -"180 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0" [id=180, type=cat]; -"181 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=181, type=batch_norm]; -"182 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_0" [id=182, type=relu]; -"183 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" [id=183, type=symmetric_quantize]; -"184 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=184, type=symmetric_quantize]; -"185 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0" [id=185, type=conv2d]; -"186 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=186, type=batch_norm]; -"187 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_1" [id=187, type=relu]; -"188 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" [id=188, type=symmetric_quantize]; -"189 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=189, type=symmetric_quantize]; -"190 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0" [id=190, type=conv2d]; -"191 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=191, type=symmetric_quantize]; -"192 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0" [id=192, type=cat]; -"193 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=193, type=batch_norm]; -"194 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_0" [id=194, type=relu]; -"195 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" [id=195, type=symmetric_quantize]; -"196 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=196, type=symmetric_quantize]; -"197 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0" [id=197, type=conv2d]; -"198 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=198, type=batch_norm]; -"199 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_1" [id=199, type=relu]; -"200 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" [id=200, type=symmetric_quantize]; -"201 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=201, type=symmetric_quantize]; -"202 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0" [id=202, type=conv2d]; -"203 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; -"204 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0" [id=204, type=cat]; -"205 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=205, type=batch_norm]; -"206 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_0" [id=206, type=relu]; -"207 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; -"208 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=208, type=symmetric_quantize]; -"209 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0" [id=209, type=conv2d]; -"210 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=210, type=batch_norm]; -"211 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_1" [id=211, type=relu]; -"212 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" [id=212, type=symmetric_quantize]; -"213 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=213, type=symmetric_quantize]; -"214 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0" [id=214, type=conv2d]; -"215 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=215, type=symmetric_quantize]; -"216 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0" [id=216, type=cat]; -"217 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=217, type=batch_norm]; -"218 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_0" [id=218, type=relu]; -"219 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" [id=219, type=symmetric_quantize]; -"220 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=220, type=symmetric_quantize]; -"221 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0" [id=221, type=conv2d]; -"222 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=222, type=batch_norm]; -"223 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_1" [id=223, type=relu]; -"224 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" [id=224, type=symmetric_quantize]; -"225 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=225, type=symmetric_quantize]; -"226 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0" [id=226, type=conv2d]; -"227 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=227, type=symmetric_quantize]; -"228 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0" [id=228, type=cat]; -"229 DenseNet/Transition[trans2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=229, type=batch_norm]; -"230 DenseNet/Transition[trans2]/relu_0" [id=230, type=relu]; -"231 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_0" [id=231, type=symmetric_quantize]; -"232 DenseNet/Transition[trans2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=232, type=symmetric_quantize]; -"233 DenseNet/Transition[trans2]/NNCFConv2d[conv]/conv2d_0" [id=233, type=conv2d]; -"234 DenseNet/Transition[trans2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; -"235 DenseNet/Transition[trans2]/avg_pool2d_0" [id=235, type=avg_pool2d]; -"236 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1" [id=236, type=symmetric_quantize]; -"237 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=237, type=batch_norm]; -"238 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_0" [id=238, type=relu]; -"239 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; -"240 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=240, type=symmetric_quantize]; -"241 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=241, type=conv2d]; -"242 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=242, type=batch_norm]; -"243 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_1" [id=243, type=relu]; -"244 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=244, type=symmetric_quantize]; -"245 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=245, type=symmetric_quantize]; -"246 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=246, type=conv2d]; -"247 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=247, type=symmetric_quantize]; -"248 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0" [id=248, type=cat]; -"249 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=249, type=batch_norm]; -"250 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_0" [id=250, type=relu]; -"251 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=251, type=symmetric_quantize]; -"252 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=252, type=symmetric_quantize]; -"253 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=253, type=conv2d]; -"254 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=254, type=batch_norm]; -"255 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_1" [id=255, type=relu]; -"256 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=256, type=symmetric_quantize]; -"257 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=257, type=symmetric_quantize]; -"258 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=258, type=conv2d]; -"259 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=259, type=symmetric_quantize]; -"260 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0" [id=260, type=cat]; -"261 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=261, type=batch_norm]; -"262 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_0" [id=262, type=relu]; -"263 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=263, type=symmetric_quantize]; -"264 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=264, type=symmetric_quantize]; -"265 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=265, type=conv2d]; -"266 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=266, type=batch_norm]; -"267 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_1" [id=267, type=relu]; -"268 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=268, type=symmetric_quantize]; -"269 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=269, type=symmetric_quantize]; -"270 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=270, type=conv2d]; -"271 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=271, type=symmetric_quantize]; -"272 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0" [id=272, type=cat]; -"273 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=273, type=batch_norm]; -"274 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_0" [id=274, type=relu]; -"275 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; -"276 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=276, type=symmetric_quantize]; -"277 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=277, type=conv2d]; -"278 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=278, type=batch_norm]; -"279 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_1" [id=279, type=relu]; -"280 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=280, type=symmetric_quantize]; -"281 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=281, type=symmetric_quantize]; -"282 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=282, type=conv2d]; -"283 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; -"284 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0" [id=284, type=cat]; -"285 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=285, type=batch_norm]; -"286 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_0" [id=286, type=relu]; -"287 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=287, type=symmetric_quantize]; -"288 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=288, type=symmetric_quantize]; -"289 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=289, type=conv2d]; -"290 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=290, type=batch_norm]; -"291 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_1" [id=291, type=relu]; -"292 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=292, type=symmetric_quantize]; -"293 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=293, type=symmetric_quantize]; -"294 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=294, type=conv2d]; -"295 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=295, type=symmetric_quantize]; -"296 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0" [id=296, type=cat]; -"297 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=297, type=batch_norm]; -"298 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_0" [id=298, type=relu]; -"299 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=299, type=symmetric_quantize]; -"300 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=300, type=symmetric_quantize]; -"301 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=301, type=conv2d]; -"302 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=302, type=batch_norm]; -"303 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_1" [id=303, type=relu]; -"304 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=304, type=symmetric_quantize]; -"305 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=305, type=symmetric_quantize]; -"306 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=306, type=conv2d]; -"307 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=307, type=symmetric_quantize]; -"308 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0" [id=308, type=cat]; -"309 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=309, type=batch_norm]; -"310 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_0" [id=310, type=relu]; -"311 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" [id=311, type=symmetric_quantize]; -"312 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=312, type=symmetric_quantize]; -"313 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0" [id=313, type=conv2d]; -"314 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=314, type=batch_norm]; -"315 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_1" [id=315, type=relu]; -"316 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" [id=316, type=symmetric_quantize]; -"317 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=317, type=symmetric_quantize]; -"318 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0" [id=318, type=conv2d]; -"319 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=319, type=symmetric_quantize]; -"320 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0" [id=320, type=cat]; -"321 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=321, type=batch_norm]; -"322 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_0" [id=322, type=relu]; -"323 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" [id=323, type=symmetric_quantize]; -"324 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=324, type=symmetric_quantize]; -"325 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0" [id=325, type=conv2d]; -"326 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=326, type=batch_norm]; -"327 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_1" [id=327, type=relu]; -"328 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" [id=328, type=symmetric_quantize]; -"329 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=329, type=symmetric_quantize]; -"330 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0" [id=330, type=conv2d]; -"331 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=331, type=symmetric_quantize]; -"332 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0" [id=332, type=cat]; -"333 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=333, type=batch_norm]; -"334 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_0" [id=334, type=relu]; -"335 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" [id=335, type=symmetric_quantize]; -"336 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=336, type=symmetric_quantize]; -"337 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0" [id=337, type=conv2d]; -"338 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=338, type=batch_norm]; -"339 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_1" [id=339, type=relu]; -"340 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" [id=340, type=symmetric_quantize]; -"341 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=341, type=symmetric_quantize]; -"342 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0" [id=342, type=conv2d]; -"343 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=343, type=symmetric_quantize]; -"344 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0" [id=344, type=cat]; -"345 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=345, type=batch_norm]; -"346 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_0" [id=346, type=relu]; -"347 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; -"348 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=348, type=symmetric_quantize]; -"349 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0" [id=349, type=conv2d]; -"350 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=350, type=batch_norm]; -"351 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_1" [id=351, type=relu]; -"352 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" [id=352, type=symmetric_quantize]; -"353 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=353, type=symmetric_quantize]; -"354 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0" [id=354, type=conv2d]; -"355 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=355, type=symmetric_quantize]; -"356 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0" [id=356, type=cat]; -"357 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=357, type=batch_norm]; -"358 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_0" [id=358, type=relu]; -"359 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" [id=359, type=symmetric_quantize]; -"360 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=360, type=symmetric_quantize]; -"361 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0" [id=361, type=conv2d]; -"362 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=362, type=batch_norm]; -"363 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_1" [id=363, type=relu]; -"364 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" [id=364, type=symmetric_quantize]; -"365 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=365, type=symmetric_quantize]; -"366 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0" [id=366, type=conv2d]; -"367 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=367, type=symmetric_quantize]; -"368 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0" [id=368, type=cat]; -"369 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=369, type=batch_norm]; -"370 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_0" [id=370, type=relu]; -"371 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" [id=371, type=symmetric_quantize]; -"372 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=372, type=symmetric_quantize]; -"373 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0" [id=373, type=conv2d]; -"374 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=374, type=batch_norm]; -"375 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_1" [id=375, type=relu]; -"376 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" [id=376, type=symmetric_quantize]; -"377 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=377, type=symmetric_quantize]; -"378 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0" [id=378, type=conv2d]; -"379 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=379, type=symmetric_quantize]; -"380 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0" [id=380, type=cat]; -"381 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=381, type=batch_norm]; -"382 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_0" [id=382, type=relu]; -"383 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" [id=383, type=symmetric_quantize]; -"384 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=384, type=symmetric_quantize]; -"385 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0" [id=385, type=conv2d]; -"386 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=386, type=batch_norm]; -"387 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_1" [id=387, type=relu]; -"388 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" [id=388, type=symmetric_quantize]; -"389 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=389, type=symmetric_quantize]; -"390 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0" [id=390, type=conv2d]; -"391 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=391, type=symmetric_quantize]; -"392 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0" [id=392, type=cat]; -"393 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=393, type=batch_norm]; -"394 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_0" [id=394, type=relu]; -"395 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" [id=395, type=symmetric_quantize]; -"396 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=396, type=symmetric_quantize]; -"397 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0" [id=397, type=conv2d]; -"398 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=398, type=batch_norm]; -"399 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_1" [id=399, type=relu]; -"400 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" [id=400, type=symmetric_quantize]; -"401 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=401, type=symmetric_quantize]; -"402 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0" [id=402, type=conv2d]; -"403 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=403, type=symmetric_quantize]; -"404 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0" [id=404, type=cat]; -"405 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=405, type=batch_norm]; -"406 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_0" [id=406, type=relu]; -"407 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" [id=407, type=symmetric_quantize]; -"408 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=408, type=symmetric_quantize]; -"409 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0" [id=409, type=conv2d]; -"410 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=410, type=batch_norm]; -"411 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_1" [id=411, type=relu]; -"412 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" [id=412, type=symmetric_quantize]; -"413 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=413, type=symmetric_quantize]; -"414 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0" [id=414, type=conv2d]; -"415 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=415, type=symmetric_quantize]; -"416 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0" [id=416, type=cat]; -"417 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=417, type=batch_norm]; -"418 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_0" [id=418, type=relu]; -"419 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" [id=419, type=symmetric_quantize]; -"420 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=420, type=symmetric_quantize]; -"421 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0" [id=421, type=conv2d]; -"422 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=422, type=batch_norm]; -"423 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_1" [id=423, type=relu]; -"424 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" [id=424, type=symmetric_quantize]; -"425 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=425, type=symmetric_quantize]; -"426 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0" [id=426, type=conv2d]; -"427 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=427, type=symmetric_quantize]; -"428 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0" [id=428, type=cat]; -"429 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=429, type=batch_norm]; -"430 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_0" [id=430, type=relu]; -"431 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_0" [id=431, type=symmetric_quantize]; -"432 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=432, type=symmetric_quantize]; -"433 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv1]/conv2d_0" [id=433, type=conv2d]; -"434 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=434, type=batch_norm]; -"435 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_1" [id=435, type=relu]; -"436 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_1" [id=436, type=symmetric_quantize]; -"437 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=437, type=symmetric_quantize]; -"438 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/conv2d_0" [id=438, type=conv2d]; -"439 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=439, type=symmetric_quantize]; -"440 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0" [id=440, type=cat]; -"441 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=441, type=batch_norm]; -"442 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_0" [id=442, type=relu]; -"443 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_0" [id=443, type=symmetric_quantize]; -"444 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=444, type=symmetric_quantize]; -"445 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv1]/conv2d_0" [id=445, type=conv2d]; -"446 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=446, type=batch_norm]; -"447 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_1" [id=447, type=relu]; -"448 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_1" [id=448, type=symmetric_quantize]; -"449 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=449, type=symmetric_quantize]; -"450 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/conv2d_0" [id=450, type=conv2d]; -"451 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=451, type=symmetric_quantize]; -"452 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0" [id=452, type=cat]; -"453 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=453, type=batch_norm]; -"454 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_0" [id=454, type=relu]; -"455 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_0" [id=455, type=symmetric_quantize]; -"456 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=456, type=symmetric_quantize]; -"457 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv1]/conv2d_0" [id=457, type=conv2d]; -"458 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=458, type=batch_norm]; -"459 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_1" [id=459, type=relu]; -"460 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_1" [id=460, type=symmetric_quantize]; -"461 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=461, type=symmetric_quantize]; -"462 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/conv2d_0" [id=462, type=conv2d]; -"463 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=463, type=symmetric_quantize]; -"464 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0" [id=464, type=cat]; -"465 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=465, type=batch_norm]; -"466 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_0" [id=466, type=relu]; -"467 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_0" [id=467, type=symmetric_quantize]; -"468 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=468, type=symmetric_quantize]; -"469 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv1]/conv2d_0" [id=469, type=conv2d]; -"470 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=470, type=batch_norm]; -"471 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_1" [id=471, type=relu]; -"472 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_1" [id=472, type=symmetric_quantize]; -"473 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=473, type=symmetric_quantize]; -"474 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/conv2d_0" [id=474, type=conv2d]; -"475 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=475, type=symmetric_quantize]; -"476 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0" [id=476, type=cat]; -"477 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=477, type=batch_norm]; -"478 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_0" [id=478, type=relu]; -"479 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_0" [id=479, type=symmetric_quantize]; -"480 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=480, type=symmetric_quantize]; -"481 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv1]/conv2d_0" [id=481, type=conv2d]; -"482 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=482, type=batch_norm]; -"483 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_1" [id=483, type=relu]; -"484 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_1" [id=484, type=symmetric_quantize]; -"485 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=485, type=symmetric_quantize]; -"486 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/conv2d_0" [id=486, type=conv2d]; -"487 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=487, type=symmetric_quantize]; -"488 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0" [id=488, type=cat]; -"489 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=489, type=batch_norm]; -"490 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_0" [id=490, type=relu]; -"491 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_0" [id=491, type=symmetric_quantize]; -"492 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=492, type=symmetric_quantize]; -"493 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv1]/conv2d_0" [id=493, type=conv2d]; -"494 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=494, type=batch_norm]; -"495 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_1" [id=495, type=relu]; -"496 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_1" [id=496, type=symmetric_quantize]; -"497 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=497, type=symmetric_quantize]; -"498 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/conv2d_0" [id=498, type=conv2d]; -"499 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=499, type=symmetric_quantize]; -"500 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0" [id=500, type=cat]; -"501 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=501, type=batch_norm]; -"502 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_0" [id=502, type=relu]; -"503 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_0" [id=503, type=symmetric_quantize]; -"504 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=504, type=symmetric_quantize]; -"505 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv1]/conv2d_0" [id=505, type=conv2d]; -"506 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=506, type=batch_norm]; -"507 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_1" [id=507, type=relu]; -"508 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_1" [id=508, type=symmetric_quantize]; -"509 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=509, type=symmetric_quantize]; -"510 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/conv2d_0" [id=510, type=conv2d]; -"511 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=511, type=symmetric_quantize]; -"512 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0" [id=512, type=cat]; -"513 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=513, type=batch_norm]; -"514 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_0" [id=514, type=relu]; -"515 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_0" [id=515, type=symmetric_quantize]; -"516 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=516, type=symmetric_quantize]; -"517 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv1]/conv2d_0" [id=517, type=conv2d]; -"518 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=518, type=batch_norm]; -"519 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_1" [id=519, type=relu]; -"520 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_1" [id=520, type=symmetric_quantize]; -"521 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=521, type=symmetric_quantize]; -"522 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/conv2d_0" [id=522, type=conv2d]; -"523 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=523, type=symmetric_quantize]; -"524 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0" [id=524, type=cat]; -"525 DenseNet/Transition[trans3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=525, type=batch_norm]; -"526 DenseNet/Transition[trans3]/relu_0" [id=526, type=relu]; -"527 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_0" [id=527, type=symmetric_quantize]; -"528 DenseNet/Transition[trans3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=528, type=symmetric_quantize]; -"529 DenseNet/Transition[trans3]/NNCFConv2d[conv]/conv2d_0" [id=529, type=conv2d]; -"530 DenseNet/Transition[trans3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=530, type=symmetric_quantize]; -"531 DenseNet/Transition[trans3]/avg_pool2d_0" [id=531, type=avg_pool2d]; -"532 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1" [id=532, type=symmetric_quantize]; -"533 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=533, type=batch_norm]; -"534 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_0" [id=534, type=relu]; -"535 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=535, type=symmetric_quantize]; -"536 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=536, type=symmetric_quantize]; -"537 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=537, type=conv2d]; -"538 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=538, type=batch_norm]; -"539 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_1" [id=539, type=relu]; -"540 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=540, type=symmetric_quantize]; -"541 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=541, type=symmetric_quantize]; -"542 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=542, type=conv2d]; -"543 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=543, type=symmetric_quantize]; -"544 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0" [id=544, type=cat]; -"545 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=545, type=batch_norm]; -"546 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_0" [id=546, type=relu]; -"547 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=547, type=symmetric_quantize]; -"548 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=548, type=symmetric_quantize]; -"549 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=549, type=conv2d]; -"550 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=550, type=batch_norm]; -"551 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_1" [id=551, type=relu]; -"552 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=552, type=symmetric_quantize]; -"553 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=553, type=symmetric_quantize]; -"554 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=554, type=conv2d]; -"555 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=555, type=symmetric_quantize]; -"556 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0" [id=556, type=cat]; -"557 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=557, type=batch_norm]; -"558 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_0" [id=558, type=relu]; -"559 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=559, type=symmetric_quantize]; -"560 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=560, type=symmetric_quantize]; -"561 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=561, type=conv2d]; -"562 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=562, type=batch_norm]; -"563 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_1" [id=563, type=relu]; -"564 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=564, type=symmetric_quantize]; -"565 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=565, type=symmetric_quantize]; -"566 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=566, type=conv2d]; -"567 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=567, type=symmetric_quantize]; -"568 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0" [id=568, type=cat]; -"569 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=569, type=batch_norm]; -"570 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_0" [id=570, type=relu]; -"571 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=571, type=symmetric_quantize]; -"572 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=572, type=symmetric_quantize]; -"573 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=573, type=conv2d]; -"574 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=574, type=batch_norm]; -"575 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_1" [id=575, type=relu]; -"576 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=576, type=symmetric_quantize]; -"577 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=577, type=symmetric_quantize]; -"578 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=578, type=conv2d]; -"579 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=579, type=symmetric_quantize]; -"580 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0" [id=580, type=cat]; -"581 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=581, type=batch_norm]; -"582 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_0" [id=582, type=relu]; -"583 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=583, type=symmetric_quantize]; -"584 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=584, type=symmetric_quantize]; -"585 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=585, type=conv2d]; -"586 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=586, type=batch_norm]; -"587 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_1" [id=587, type=relu]; -"588 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=588, type=symmetric_quantize]; -"589 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=589, type=symmetric_quantize]; -"590 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=590, type=conv2d]; -"591 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=591, type=symmetric_quantize]; -"592 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0" [id=592, type=cat]; -"593 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=593, type=batch_norm]; -"594 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_0" [id=594, type=relu]; -"595 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=595, type=symmetric_quantize]; -"596 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=596, type=symmetric_quantize]; -"597 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=597, type=conv2d]; -"598 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=598, type=batch_norm]; -"599 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_1" [id=599, type=relu]; -"600 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=600, type=symmetric_quantize]; -"601 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=601, type=symmetric_quantize]; -"602 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=602, type=conv2d]; -"603 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=603, type=symmetric_quantize]; -"604 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0" [id=604, type=cat]; -"605 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=605, type=batch_norm]; -"606 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_0" [id=606, type=relu]; -"607 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" [id=607, type=symmetric_quantize]; -"608 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=608, type=symmetric_quantize]; -"609 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0" [id=609, type=conv2d]; -"610 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=610, type=batch_norm]; -"611 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_1" [id=611, type=relu]; -"612 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" [id=612, type=symmetric_quantize]; -"613 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=613, type=symmetric_quantize]; -"614 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0" [id=614, type=conv2d]; -"615 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=615, type=symmetric_quantize]; -"616 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0" [id=616, type=cat]; -"617 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=617, type=batch_norm]; -"618 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_0" [id=618, type=relu]; -"619 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" [id=619, type=symmetric_quantize]; -"620 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=620, type=symmetric_quantize]; -"621 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0" [id=621, type=conv2d]; -"622 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=622, type=batch_norm]; -"623 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_1" [id=623, type=relu]; -"624 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" [id=624, type=symmetric_quantize]; -"625 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=625, type=symmetric_quantize]; -"626 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0" [id=626, type=conv2d]; -"627 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=627, type=symmetric_quantize]; -"628 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0" [id=628, type=cat]; -"629 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=629, type=batch_norm]; -"630 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_0" [id=630, type=relu]; -"631 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" [id=631, type=symmetric_quantize]; -"632 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=632, type=symmetric_quantize]; -"633 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0" [id=633, type=conv2d]; -"634 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=634, type=batch_norm]; -"635 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_1" [id=635, type=relu]; -"636 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" [id=636, type=symmetric_quantize]; -"637 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=637, type=symmetric_quantize]; -"638 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0" [id=638, type=conv2d]; -"639 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=639, type=symmetric_quantize]; -"640 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0" [id=640, type=cat]; -"641 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=641, type=batch_norm]; -"642 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_0" [id=642, type=relu]; -"643 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" [id=643, type=symmetric_quantize]; -"644 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=644, type=symmetric_quantize]; -"645 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0" [id=645, type=conv2d]; -"646 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=646, type=batch_norm]; -"647 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_1" [id=647, type=relu]; -"648 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" [id=648, type=symmetric_quantize]; -"649 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=649, type=symmetric_quantize]; -"650 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0" [id=650, type=conv2d]; -"651 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=651, type=symmetric_quantize]; -"652 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0" [id=652, type=cat]; -"653 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=653, type=batch_norm]; -"654 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_0" [id=654, type=relu]; -"655 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" [id=655, type=symmetric_quantize]; -"656 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=656, type=symmetric_quantize]; -"657 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0" [id=657, type=conv2d]; -"658 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=658, type=batch_norm]; -"659 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_1" [id=659, type=relu]; -"660 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" [id=660, type=symmetric_quantize]; -"661 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=661, type=symmetric_quantize]; -"662 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0" [id=662, type=conv2d]; -"663 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=663, type=symmetric_quantize]; -"664 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0" [id=664, type=cat]; -"665 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=665, type=batch_norm]; -"666 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_0" [id=666, type=relu]; -"667 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" [id=667, type=symmetric_quantize]; -"668 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=668, type=symmetric_quantize]; -"669 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0" [id=669, type=conv2d]; -"670 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=670, type=batch_norm]; -"671 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_1" [id=671, type=relu]; -"672 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" [id=672, type=symmetric_quantize]; -"673 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=673, type=symmetric_quantize]; -"674 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0" [id=674, type=conv2d]; -"675 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=675, type=symmetric_quantize]; -"676 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0" [id=676, type=cat]; -"677 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=677, type=batch_norm]; -"678 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_0" [id=678, type=relu]; -"679 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" [id=679, type=symmetric_quantize]; -"680 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=680, type=symmetric_quantize]; -"681 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0" [id=681, type=conv2d]; -"682 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=682, type=batch_norm]; -"683 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_1" [id=683, type=relu]; -"684 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" [id=684, type=symmetric_quantize]; -"685 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=685, type=symmetric_quantize]; -"686 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0" [id=686, type=conv2d]; -"687 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=687, type=symmetric_quantize]; -"688 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0" [id=688, type=cat]; -"689 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=689, type=batch_norm]; -"690 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_0" [id=690, type=relu]; -"691 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" [id=691, type=symmetric_quantize]; -"692 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=692, type=symmetric_quantize]; -"693 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0" [id=693, type=conv2d]; -"694 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=694, type=batch_norm]; -"695 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_1" [id=695, type=relu]; -"696 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" [id=696, type=symmetric_quantize]; -"697 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=697, type=symmetric_quantize]; -"698 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0" [id=698, type=conv2d]; -"699 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=699, type=symmetric_quantize]; -"700 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0" [id=700, type=cat]; -"701 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=701, type=batch_norm]; -"702 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_0" [id=702, type=relu]; -"703 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" [id=703, type=symmetric_quantize]; -"704 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=704, type=symmetric_quantize]; -"705 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0" [id=705, type=conv2d]; -"706 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=706, type=batch_norm]; -"707 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_1" [id=707, type=relu]; -"708 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" [id=708, type=symmetric_quantize]; -"709 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=709, type=symmetric_quantize]; -"710 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0" [id=710, type=conv2d]; -"711 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=711, type=symmetric_quantize]; -"712 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0" [id=712, type=cat]; -"713 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=713, type=batch_norm]; -"714 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_0" [id=714, type=relu]; -"715 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" [id=715, type=symmetric_quantize]; -"716 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=716, type=symmetric_quantize]; -"717 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0" [id=717, type=conv2d]; -"718 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=718, type=batch_norm]; -"719 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_1" [id=719, type=relu]; -"720 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" [id=720, type=symmetric_quantize]; -"721 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=721, type=symmetric_quantize]; -"722 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0" [id=722, type=conv2d]; -"723 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=723, type=symmetric_quantize]; -"724 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0" [id=724, type=cat]; -"725 DenseNet/NNCFBatchNorm2d[bn]/batch_norm_0" [id=725, type=batch_norm]; -"726 DenseNet/relu_0" [id=726, type=relu]; -"727 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=727, type=symmetric_quantize]; -"728 DenseNet/avg_pool2d_0" [id=728, type=avg_pool2d]; -"729 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=729, type=symmetric_quantize]; -"730 DenseNet/view_0" [id=730, type=view]; -"731 DenseNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=731, type=symmetric_quantize]; -"732 DenseNet/NNCFLinear[linear]/linear_0" [id=732, type=linear]; -"733 /nncf_model_output_0" [id=733, type=nncf_model_output]; +"2 conv1.weight" [id=2, type=nncf_model_const]; +"3 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 DenseNet/Conv2d[conv1]/conv2d_0" [id=4, type=conv2d]; +"5 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_1" [id=5, type=symmetric_quantize]; +"6 dense1.0.bn1.weight" [id=6, type=nncf_model_const]; +"7 dense1.0.bn1.bias" [id=7, type=nncf_model_const]; +"8 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=8, type=batch_norm]; +"9 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_0" [id=9, type=relu]; +"10 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; +"11 dense1.0.conv1.weight" [id=11, type=nncf_model_const]; +"12 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=13, type=conv2d]; +"14 dense1.0.bn2.weight" [id=14, type=nncf_model_const]; +"15 dense1.0.bn2.bias" [id=15, type=nncf_model_const]; +"16 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=16, type=batch_norm]; +"17 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_1" [id=17, type=relu]; +"18 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=18, type=symmetric_quantize]; +"19 dense1.0.conv2.weight" [id=19, type=nncf_model_const]; +"20 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=21, type=conv2d]; +"22 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=22, type=symmetric_quantize]; +"23 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0" [id=23, type=cat]; +"24 dense1.1.bn1.weight" [id=24, type=nncf_model_const]; +"25 dense1.1.bn1.bias" [id=25, type=nncf_model_const]; +"26 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=26, type=batch_norm]; +"27 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_0" [id=27, type=relu]; +"28 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; +"29 dense1.1.conv1.weight" [id=29, type=nncf_model_const]; +"30 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=31, type=conv2d]; +"32 dense1.1.bn2.weight" [id=32, type=nncf_model_const]; +"33 dense1.1.bn2.bias" [id=33, type=nncf_model_const]; +"34 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=34, type=batch_norm]; +"35 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_1" [id=35, type=relu]; +"36 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=36, type=symmetric_quantize]; +"37 dense1.1.conv2.weight" [id=37, type=nncf_model_const]; +"38 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=39, type=conv2d]; +"40 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=40, type=symmetric_quantize]; +"41 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0" [id=41, type=cat]; +"42 dense1.2.bn1.weight" [id=42, type=nncf_model_const]; +"43 dense1.2.bn1.bias" [id=43, type=nncf_model_const]; +"44 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=44, type=batch_norm]; +"45 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_0" [id=45, type=relu]; +"46 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 dense1.2.conv1.weight" [id=47, type=nncf_model_const]; +"48 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=49, type=conv2d]; +"50 dense1.2.bn2.weight" [id=50, type=nncf_model_const]; +"51 dense1.2.bn2.bias" [id=51, type=nncf_model_const]; +"52 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=52, type=batch_norm]; +"53 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_1" [id=53, type=relu]; +"54 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=54, type=symmetric_quantize]; +"55 dense1.2.conv2.weight" [id=55, type=nncf_model_const]; +"56 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=57, type=conv2d]; +"58 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=58, type=symmetric_quantize]; +"59 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0" [id=59, type=cat]; +"60 dense1.3.bn1.weight" [id=60, type=nncf_model_const]; +"61 dense1.3.bn1.bias" [id=61, type=nncf_model_const]; +"62 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" [id=62, type=batch_norm]; +"63 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_0" [id=63, type=relu]; +"64 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; +"65 dense1.3.conv1.weight" [id=65, type=nncf_model_const]; +"66 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=66, type=symmetric_quantize]; +"67 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" [id=67, type=conv2d]; +"68 dense1.3.bn2.weight" [id=68, type=nncf_model_const]; +"69 dense1.3.bn2.bias" [id=69, type=nncf_model_const]; +"70 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" [id=70, type=batch_norm]; +"71 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_1" [id=71, type=relu]; +"72 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=72, type=symmetric_quantize]; +"73 dense1.3.conv2.weight" [id=73, type=nncf_model_const]; +"74 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; +"75 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" [id=75, type=conv2d]; +"76 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=76, type=symmetric_quantize]; +"77 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0" [id=77, type=cat]; +"78 dense1.4.bn1.weight" [id=78, type=nncf_model_const]; +"79 dense1.4.bn1.bias" [id=79, type=nncf_model_const]; +"80 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" [id=80, type=batch_norm]; +"81 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_0" [id=81, type=relu]; +"82 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=82, type=symmetric_quantize]; +"83 dense1.4.conv1.weight" [id=83, type=nncf_model_const]; +"84 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" [id=85, type=conv2d]; +"86 dense1.4.bn2.weight" [id=86, type=nncf_model_const]; +"87 dense1.4.bn2.bias" [id=87, type=nncf_model_const]; +"88 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" [id=88, type=batch_norm]; +"89 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_1" [id=89, type=relu]; +"90 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=90, type=symmetric_quantize]; +"91 dense1.4.conv2.weight" [id=91, type=nncf_model_const]; +"92 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=92, type=symmetric_quantize]; +"93 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" [id=93, type=conv2d]; +"94 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=94, type=symmetric_quantize]; +"95 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0" [id=95, type=cat]; +"96 dense1.5.bn1.weight" [id=96, type=nncf_model_const]; +"97 dense1.5.bn1.bias" [id=97, type=nncf_model_const]; +"98 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" [id=98, type=batch_norm]; +"99 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_0" [id=99, type=relu]; +"100 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; +"101 dense1.5.conv1.weight" [id=101, type=nncf_model_const]; +"102 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" [id=103, type=conv2d]; +"104 dense1.5.bn2.weight" [id=104, type=nncf_model_const]; +"105 dense1.5.bn2.bias" [id=105, type=nncf_model_const]; +"106 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" [id=106, type=batch_norm]; +"107 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_1" [id=107, type=relu]; +"108 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=108, type=symmetric_quantize]; +"109 dense1.5.conv2.weight" [id=109, type=nncf_model_const]; +"110 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" [id=111, type=conv2d]; +"112 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=112, type=symmetric_quantize]; +"113 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0" [id=113, type=cat]; +"114 trans1.bn.weight" [id=114, type=nncf_model_const]; +"115 trans1.bn.bias" [id=115, type=nncf_model_const]; +"116 DenseNet/Transition[trans1]/BatchNorm2d[bn]/batch_norm_0" [id=116, type=batch_norm]; +"117 DenseNet/Transition[trans1]/relu_0" [id=117, type=relu]; +"118 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_0" [id=118, type=symmetric_quantize]; +"119 trans1.conv.weight" [id=119, type=nncf_model_const]; +"120 DenseNet/Transition[trans1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 DenseNet/Transition[trans1]/Conv2d[conv]/conv2d_0" [id=121, type=conv2d]; +"122 DenseNet/Transition[trans1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=122, type=symmetric_quantize]; +"123 DenseNet/Transition[trans1]/avg_pool2d_0" [id=123, type=avg_pool2d]; +"124 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1" [id=124, type=symmetric_quantize]; +"125 dense2.0.bn1.weight" [id=125, type=nncf_model_const]; +"126 dense2.0.bn1.bias" [id=126, type=nncf_model_const]; +"127 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=127, type=batch_norm]; +"128 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_0" [id=128, type=relu]; +"129 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 dense2.0.conv1.weight" [id=130, type=nncf_model_const]; +"131 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; +"132 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=132, type=conv2d]; +"133 dense2.0.bn2.weight" [id=133, type=nncf_model_const]; +"134 dense2.0.bn2.bias" [id=134, type=nncf_model_const]; +"135 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=135, type=batch_norm]; +"136 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_1" [id=136, type=relu]; +"137 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=137, type=symmetric_quantize]; +"138 dense2.0.conv2.weight" [id=138, type=nncf_model_const]; +"139 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=140, type=conv2d]; +"141 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=141, type=symmetric_quantize]; +"142 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0" [id=142, type=cat]; +"143 dense2.1.bn1.weight" [id=143, type=nncf_model_const]; +"144 dense2.1.bn1.bias" [id=144, type=nncf_model_const]; +"145 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=145, type=batch_norm]; +"146 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_0" [id=146, type=relu]; +"147 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 dense2.1.conv1.weight" [id=148, type=nncf_model_const]; +"149 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=150, type=conv2d]; +"151 dense2.1.bn2.weight" [id=151, type=nncf_model_const]; +"152 dense2.1.bn2.bias" [id=152, type=nncf_model_const]; +"153 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=153, type=batch_norm]; +"154 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_1" [id=154, type=relu]; +"155 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=155, type=symmetric_quantize]; +"156 dense2.1.conv2.weight" [id=156, type=nncf_model_const]; +"157 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=157, type=symmetric_quantize]; +"158 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=158, type=conv2d]; +"159 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=159, type=symmetric_quantize]; +"160 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0" [id=160, type=cat]; +"161 dense2.2.bn1.weight" [id=161, type=nncf_model_const]; +"162 dense2.2.bn1.bias" [id=162, type=nncf_model_const]; +"163 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=163, type=batch_norm]; +"164 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_0" [id=164, type=relu]; +"165 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=165, type=symmetric_quantize]; +"166 dense2.2.conv1.weight" [id=166, type=nncf_model_const]; +"167 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; +"168 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=168, type=conv2d]; +"169 dense2.2.bn2.weight" [id=169, type=nncf_model_const]; +"170 dense2.2.bn2.bias" [id=170, type=nncf_model_const]; +"171 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=171, type=batch_norm]; +"172 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_1" [id=172, type=relu]; +"173 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=173, type=symmetric_quantize]; +"174 dense2.2.conv2.weight" [id=174, type=nncf_model_const]; +"175 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=175, type=symmetric_quantize]; +"176 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=176, type=conv2d]; +"177 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=177, type=symmetric_quantize]; +"178 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0" [id=178, type=cat]; +"179 dense2.3.bn1.weight" [id=179, type=nncf_model_const]; +"180 dense2.3.bn1.bias" [id=180, type=nncf_model_const]; +"181 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" [id=181, type=batch_norm]; +"182 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_0" [id=182, type=relu]; +"183 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 dense2.3.conv1.weight" [id=184, type=nncf_model_const]; +"185 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=185, type=symmetric_quantize]; +"186 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" [id=186, type=conv2d]; +"187 dense2.3.bn2.weight" [id=187, type=nncf_model_const]; +"188 dense2.3.bn2.bias" [id=188, type=nncf_model_const]; +"189 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" [id=189, type=batch_norm]; +"190 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_1" [id=190, type=relu]; +"191 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=191, type=symmetric_quantize]; +"192 dense2.3.conv2.weight" [id=192, type=nncf_model_const]; +"193 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; +"194 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" [id=194, type=conv2d]; +"195 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=195, type=symmetric_quantize]; +"196 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0" [id=196, type=cat]; +"197 dense2.4.bn1.weight" [id=197, type=nncf_model_const]; +"198 dense2.4.bn1.bias" [id=198, type=nncf_model_const]; +"199 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" [id=199, type=batch_norm]; +"200 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_0" [id=200, type=relu]; +"201 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=201, type=symmetric_quantize]; +"202 dense2.4.conv1.weight" [id=202, type=nncf_model_const]; +"203 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; +"204 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" [id=204, type=conv2d]; +"205 dense2.4.bn2.weight" [id=205, type=nncf_model_const]; +"206 dense2.4.bn2.bias" [id=206, type=nncf_model_const]; +"207 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" [id=207, type=batch_norm]; +"208 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_1" [id=208, type=relu]; +"209 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=209, type=symmetric_quantize]; +"210 dense2.4.conv2.weight" [id=210, type=nncf_model_const]; +"211 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=211, type=symmetric_quantize]; +"212 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" [id=212, type=conv2d]; +"213 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=213, type=symmetric_quantize]; +"214 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0" [id=214, type=cat]; +"215 dense2.5.bn1.weight" [id=215, type=nncf_model_const]; +"216 dense2.5.bn1.bias" [id=216, type=nncf_model_const]; +"217 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" [id=217, type=batch_norm]; +"218 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_0" [id=218, type=relu]; +"219 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=219, type=symmetric_quantize]; +"220 dense2.5.conv1.weight" [id=220, type=nncf_model_const]; +"221 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=221, type=symmetric_quantize]; +"222 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" [id=222, type=conv2d]; +"223 dense2.5.bn2.weight" [id=223, type=nncf_model_const]; +"224 dense2.5.bn2.bias" [id=224, type=nncf_model_const]; +"225 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" [id=225, type=batch_norm]; +"226 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_1" [id=226, type=relu]; +"227 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=227, type=symmetric_quantize]; +"228 dense2.5.conv2.weight" [id=228, type=nncf_model_const]; +"229 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=229, type=symmetric_quantize]; +"230 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" [id=230, type=conv2d]; +"231 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=231, type=symmetric_quantize]; +"232 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0" [id=232, type=cat]; +"233 dense2.6.bn1.weight" [id=233, type=nncf_model_const]; +"234 dense2.6.bn1.bias" [id=234, type=nncf_model_const]; +"235 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0" [id=235, type=batch_norm]; +"236 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_0" [id=236, type=relu]; +"237 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" [id=237, type=symmetric_quantize]; +"238 dense2.6.conv1.weight" [id=238, type=nncf_model_const]; +"239 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; +"240 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/conv2d_0" [id=240, type=conv2d]; +"241 dense2.6.bn2.weight" [id=241, type=nncf_model_const]; +"242 dense2.6.bn2.bias" [id=242, type=nncf_model_const]; +"243 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0" [id=243, type=batch_norm]; +"244 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_1" [id=244, type=relu]; +"245 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" [id=245, type=symmetric_quantize]; +"246 dense2.6.conv2.weight" [id=246, type=nncf_model_const]; +"247 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=247, type=symmetric_quantize]; +"248 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/conv2d_0" [id=248, type=conv2d]; +"249 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=249, type=symmetric_quantize]; +"250 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0" [id=250, type=cat]; +"251 dense2.7.bn1.weight" [id=251, type=nncf_model_const]; +"252 dense2.7.bn1.bias" [id=252, type=nncf_model_const]; +"253 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0" [id=253, type=batch_norm]; +"254 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_0" [id=254, type=relu]; +"255 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 dense2.7.conv1.weight" [id=256, type=nncf_model_const]; +"257 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=257, type=symmetric_quantize]; +"258 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/conv2d_0" [id=258, type=conv2d]; +"259 dense2.7.bn2.weight" [id=259, type=nncf_model_const]; +"260 dense2.7.bn2.bias" [id=260, type=nncf_model_const]; +"261 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0" [id=261, type=batch_norm]; +"262 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_1" [id=262, type=relu]; +"263 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" [id=263, type=symmetric_quantize]; +"264 dense2.7.conv2.weight" [id=264, type=nncf_model_const]; +"265 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=265, type=symmetric_quantize]; +"266 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/conv2d_0" [id=266, type=conv2d]; +"267 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=267, type=symmetric_quantize]; +"268 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0" [id=268, type=cat]; +"269 dense2.8.bn1.weight" [id=269, type=nncf_model_const]; +"270 dense2.8.bn1.bias" [id=270, type=nncf_model_const]; +"271 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0" [id=271, type=batch_norm]; +"272 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_0" [id=272, type=relu]; +"273 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" [id=273, type=symmetric_quantize]; +"274 dense2.8.conv1.weight" [id=274, type=nncf_model_const]; +"275 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; +"276 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/conv2d_0" [id=276, type=conv2d]; +"277 dense2.8.bn2.weight" [id=277, type=nncf_model_const]; +"278 dense2.8.bn2.bias" [id=278, type=nncf_model_const]; +"279 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0" [id=279, type=batch_norm]; +"280 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_1" [id=280, type=relu]; +"281 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" [id=281, type=symmetric_quantize]; +"282 dense2.8.conv2.weight" [id=282, type=nncf_model_const]; +"283 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/conv2d_0" [id=284, type=conv2d]; +"285 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=285, type=symmetric_quantize]; +"286 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0" [id=286, type=cat]; +"287 dense2.9.bn1.weight" [id=287, type=nncf_model_const]; +"288 dense2.9.bn1.bias" [id=288, type=nncf_model_const]; +"289 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0" [id=289, type=batch_norm]; +"290 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_0" [id=290, type=relu]; +"291 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 dense2.9.conv1.weight" [id=292, type=nncf_model_const]; +"293 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=293, type=symmetric_quantize]; +"294 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/conv2d_0" [id=294, type=conv2d]; +"295 dense2.9.bn2.weight" [id=295, type=nncf_model_const]; +"296 dense2.9.bn2.bias" [id=296, type=nncf_model_const]; +"297 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0" [id=297, type=batch_norm]; +"298 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_1" [id=298, type=relu]; +"299 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" [id=299, type=symmetric_quantize]; +"300 dense2.9.conv2.weight" [id=300, type=nncf_model_const]; +"301 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=301, type=symmetric_quantize]; +"302 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/conv2d_0" [id=302, type=conv2d]; +"303 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=303, type=symmetric_quantize]; +"304 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0" [id=304, type=cat]; +"305 dense2.10.bn1.weight" [id=305, type=nncf_model_const]; +"306 dense2.10.bn1.bias" [id=306, type=nncf_model_const]; +"307 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0" [id=307, type=batch_norm]; +"308 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_0" [id=308, type=relu]; +"309 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" [id=309, type=symmetric_quantize]; +"310 dense2.10.conv1.weight" [id=310, type=nncf_model_const]; +"311 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=311, type=symmetric_quantize]; +"312 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/conv2d_0" [id=312, type=conv2d]; +"313 dense2.10.bn2.weight" [id=313, type=nncf_model_const]; +"314 dense2.10.bn2.bias" [id=314, type=nncf_model_const]; +"315 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0" [id=315, type=batch_norm]; +"316 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_1" [id=316, type=relu]; +"317 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" [id=317, type=symmetric_quantize]; +"318 dense2.10.conv2.weight" [id=318, type=nncf_model_const]; +"319 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=319, type=symmetric_quantize]; +"320 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/conv2d_0" [id=320, type=conv2d]; +"321 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=321, type=symmetric_quantize]; +"322 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0" [id=322, type=cat]; +"323 dense2.11.bn1.weight" [id=323, type=nncf_model_const]; +"324 dense2.11.bn1.bias" [id=324, type=nncf_model_const]; +"325 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0" [id=325, type=batch_norm]; +"326 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_0" [id=326, type=relu]; +"327 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" [id=327, type=symmetric_quantize]; +"328 dense2.11.conv1.weight" [id=328, type=nncf_model_const]; +"329 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; +"330 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/conv2d_0" [id=330, type=conv2d]; +"331 dense2.11.bn2.weight" [id=331, type=nncf_model_const]; +"332 dense2.11.bn2.bias" [id=332, type=nncf_model_const]; +"333 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0" [id=333, type=batch_norm]; +"334 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_1" [id=334, type=relu]; +"335 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" [id=335, type=symmetric_quantize]; +"336 dense2.11.conv2.weight" [id=336, type=nncf_model_const]; +"337 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/conv2d_0" [id=338, type=conv2d]; +"339 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=339, type=symmetric_quantize]; +"340 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0" [id=340, type=cat]; +"341 trans2.bn.weight" [id=341, type=nncf_model_const]; +"342 trans2.bn.bias" [id=342, type=nncf_model_const]; +"343 DenseNet/Transition[trans2]/BatchNorm2d[bn]/batch_norm_0" [id=343, type=batch_norm]; +"344 DenseNet/Transition[trans2]/relu_0" [id=344, type=relu]; +"345 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_0" [id=345, type=symmetric_quantize]; +"346 trans2.conv.weight" [id=346, type=nncf_model_const]; +"347 DenseNet/Transition[trans2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; +"348 DenseNet/Transition[trans2]/Conv2d[conv]/conv2d_0" [id=348, type=conv2d]; +"349 DenseNet/Transition[trans2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=349, type=symmetric_quantize]; +"350 DenseNet/Transition[trans2]/avg_pool2d_0" [id=350, type=avg_pool2d]; +"351 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1" [id=351, type=symmetric_quantize]; +"352 dense3.0.bn1.weight" [id=352, type=nncf_model_const]; +"353 dense3.0.bn1.bias" [id=353, type=nncf_model_const]; +"354 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=354, type=batch_norm]; +"355 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_0" [id=355, type=relu]; +"356 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=356, type=symmetric_quantize]; +"357 dense3.0.conv1.weight" [id=357, type=nncf_model_const]; +"358 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=358, type=symmetric_quantize]; +"359 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=359, type=conv2d]; +"360 dense3.0.bn2.weight" [id=360, type=nncf_model_const]; +"361 dense3.0.bn2.bias" [id=361, type=nncf_model_const]; +"362 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=362, type=batch_norm]; +"363 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_1" [id=363, type=relu]; +"364 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=364, type=symmetric_quantize]; +"365 dense3.0.conv2.weight" [id=365, type=nncf_model_const]; +"366 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=366, type=symmetric_quantize]; +"367 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=367, type=conv2d]; +"368 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=368, type=symmetric_quantize]; +"369 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0" [id=369, type=cat]; +"370 dense3.1.bn1.weight" [id=370, type=nncf_model_const]; +"371 dense3.1.bn1.bias" [id=371, type=nncf_model_const]; +"372 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=372, type=batch_norm]; +"373 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_0" [id=373, type=relu]; +"374 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=374, type=symmetric_quantize]; +"375 dense3.1.conv1.weight" [id=375, type=nncf_model_const]; +"376 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=376, type=symmetric_quantize]; +"377 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=377, type=conv2d]; +"378 dense3.1.bn2.weight" [id=378, type=nncf_model_const]; +"379 dense3.1.bn2.bias" [id=379, type=nncf_model_const]; +"380 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=380, type=batch_norm]; +"381 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_1" [id=381, type=relu]; +"382 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=382, type=symmetric_quantize]; +"383 dense3.1.conv2.weight" [id=383, type=nncf_model_const]; +"384 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=384, type=symmetric_quantize]; +"385 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=385, type=conv2d]; +"386 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=386, type=symmetric_quantize]; +"387 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0" [id=387, type=cat]; +"388 dense3.2.bn1.weight" [id=388, type=nncf_model_const]; +"389 dense3.2.bn1.bias" [id=389, type=nncf_model_const]; +"390 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=390, type=batch_norm]; +"391 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_0" [id=391, type=relu]; +"392 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=392, type=symmetric_quantize]; +"393 dense3.2.conv1.weight" [id=393, type=nncf_model_const]; +"394 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=394, type=symmetric_quantize]; +"395 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=395, type=conv2d]; +"396 dense3.2.bn2.weight" [id=396, type=nncf_model_const]; +"397 dense3.2.bn2.bias" [id=397, type=nncf_model_const]; +"398 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=398, type=batch_norm]; +"399 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_1" [id=399, type=relu]; +"400 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=400, type=symmetric_quantize]; +"401 dense3.2.conv2.weight" [id=401, type=nncf_model_const]; +"402 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=402, type=symmetric_quantize]; +"403 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=403, type=conv2d]; +"404 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=404, type=symmetric_quantize]; +"405 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0" [id=405, type=cat]; +"406 dense3.3.bn1.weight" [id=406, type=nncf_model_const]; +"407 dense3.3.bn1.bias" [id=407, type=nncf_model_const]; +"408 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" [id=408, type=batch_norm]; +"409 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_0" [id=409, type=relu]; +"410 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=410, type=symmetric_quantize]; +"411 dense3.3.conv1.weight" [id=411, type=nncf_model_const]; +"412 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=412, type=symmetric_quantize]; +"413 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" [id=413, type=conv2d]; +"414 dense3.3.bn2.weight" [id=414, type=nncf_model_const]; +"415 dense3.3.bn2.bias" [id=415, type=nncf_model_const]; +"416 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" [id=416, type=batch_norm]; +"417 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_1" [id=417, type=relu]; +"418 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=418, type=symmetric_quantize]; +"419 dense3.3.conv2.weight" [id=419, type=nncf_model_const]; +"420 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=420, type=symmetric_quantize]; +"421 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" [id=421, type=conv2d]; +"422 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=422, type=symmetric_quantize]; +"423 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0" [id=423, type=cat]; +"424 dense3.4.bn1.weight" [id=424, type=nncf_model_const]; +"425 dense3.4.bn1.bias" [id=425, type=nncf_model_const]; +"426 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" [id=426, type=batch_norm]; +"427 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_0" [id=427, type=relu]; +"428 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=428, type=symmetric_quantize]; +"429 dense3.4.conv1.weight" [id=429, type=nncf_model_const]; +"430 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=430, type=symmetric_quantize]; +"431 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" [id=431, type=conv2d]; +"432 dense3.4.bn2.weight" [id=432, type=nncf_model_const]; +"433 dense3.4.bn2.bias" [id=433, type=nncf_model_const]; +"434 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" [id=434, type=batch_norm]; +"435 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_1" [id=435, type=relu]; +"436 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=436, type=symmetric_quantize]; +"437 dense3.4.conv2.weight" [id=437, type=nncf_model_const]; +"438 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=438, type=symmetric_quantize]; +"439 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" [id=439, type=conv2d]; +"440 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=440, type=symmetric_quantize]; +"441 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0" [id=441, type=cat]; +"442 dense3.5.bn1.weight" [id=442, type=nncf_model_const]; +"443 dense3.5.bn1.bias" [id=443, type=nncf_model_const]; +"444 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" [id=444, type=batch_norm]; +"445 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_0" [id=445, type=relu]; +"446 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=446, type=symmetric_quantize]; +"447 dense3.5.conv1.weight" [id=447, type=nncf_model_const]; +"448 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=448, type=symmetric_quantize]; +"449 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" [id=449, type=conv2d]; +"450 dense3.5.bn2.weight" [id=450, type=nncf_model_const]; +"451 dense3.5.bn2.bias" [id=451, type=nncf_model_const]; +"452 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" [id=452, type=batch_norm]; +"453 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_1" [id=453, type=relu]; +"454 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=454, type=symmetric_quantize]; +"455 dense3.5.conv2.weight" [id=455, type=nncf_model_const]; +"456 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=456, type=symmetric_quantize]; +"457 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" [id=457, type=conv2d]; +"458 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=458, type=symmetric_quantize]; +"459 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0" [id=459, type=cat]; +"460 dense3.6.bn1.weight" [id=460, type=nncf_model_const]; +"461 dense3.6.bn1.bias" [id=461, type=nncf_model_const]; +"462 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0" [id=462, type=batch_norm]; +"463 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_0" [id=463, type=relu]; +"464 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" [id=464, type=symmetric_quantize]; +"465 dense3.6.conv1.weight" [id=465, type=nncf_model_const]; +"466 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=466, type=symmetric_quantize]; +"467 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/conv2d_0" [id=467, type=conv2d]; +"468 dense3.6.bn2.weight" [id=468, type=nncf_model_const]; +"469 dense3.6.bn2.bias" [id=469, type=nncf_model_const]; +"470 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0" [id=470, type=batch_norm]; +"471 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_1" [id=471, type=relu]; +"472 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" [id=472, type=symmetric_quantize]; +"473 dense3.6.conv2.weight" [id=473, type=nncf_model_const]; +"474 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=474, type=symmetric_quantize]; +"475 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/conv2d_0" [id=475, type=conv2d]; +"476 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=476, type=symmetric_quantize]; +"477 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0" [id=477, type=cat]; +"478 dense3.7.bn1.weight" [id=478, type=nncf_model_const]; +"479 dense3.7.bn1.bias" [id=479, type=nncf_model_const]; +"480 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0" [id=480, type=batch_norm]; +"481 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_0" [id=481, type=relu]; +"482 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" [id=482, type=symmetric_quantize]; +"483 dense3.7.conv1.weight" [id=483, type=nncf_model_const]; +"484 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=484, type=symmetric_quantize]; +"485 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/conv2d_0" [id=485, type=conv2d]; +"486 dense3.7.bn2.weight" [id=486, type=nncf_model_const]; +"487 dense3.7.bn2.bias" [id=487, type=nncf_model_const]; +"488 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0" [id=488, type=batch_norm]; +"489 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_1" [id=489, type=relu]; +"490 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" [id=490, type=symmetric_quantize]; +"491 dense3.7.conv2.weight" [id=491, type=nncf_model_const]; +"492 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=492, type=symmetric_quantize]; +"493 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/conv2d_0" [id=493, type=conv2d]; +"494 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=494, type=symmetric_quantize]; +"495 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0" [id=495, type=cat]; +"496 dense3.8.bn1.weight" [id=496, type=nncf_model_const]; +"497 dense3.8.bn1.bias" [id=497, type=nncf_model_const]; +"498 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0" [id=498, type=batch_norm]; +"499 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_0" [id=499, type=relu]; +"500 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" [id=500, type=symmetric_quantize]; +"501 dense3.8.conv1.weight" [id=501, type=nncf_model_const]; +"502 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=502, type=symmetric_quantize]; +"503 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/conv2d_0" [id=503, type=conv2d]; +"504 dense3.8.bn2.weight" [id=504, type=nncf_model_const]; +"505 dense3.8.bn2.bias" [id=505, type=nncf_model_const]; +"506 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0" [id=506, type=batch_norm]; +"507 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_1" [id=507, type=relu]; +"508 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" [id=508, type=symmetric_quantize]; +"509 dense3.8.conv2.weight" [id=509, type=nncf_model_const]; +"510 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=510, type=symmetric_quantize]; +"511 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/conv2d_0" [id=511, type=conv2d]; +"512 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=512, type=symmetric_quantize]; +"513 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0" [id=513, type=cat]; +"514 dense3.9.bn1.weight" [id=514, type=nncf_model_const]; +"515 dense3.9.bn1.bias" [id=515, type=nncf_model_const]; +"516 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0" [id=516, type=batch_norm]; +"517 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_0" [id=517, type=relu]; +"518 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" [id=518, type=symmetric_quantize]; +"519 dense3.9.conv1.weight" [id=519, type=nncf_model_const]; +"520 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=520, type=symmetric_quantize]; +"521 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/conv2d_0" [id=521, type=conv2d]; +"522 dense3.9.bn2.weight" [id=522, type=nncf_model_const]; +"523 dense3.9.bn2.bias" [id=523, type=nncf_model_const]; +"524 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0" [id=524, type=batch_norm]; +"525 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_1" [id=525, type=relu]; +"526 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" [id=526, type=symmetric_quantize]; +"527 dense3.9.conv2.weight" [id=527, type=nncf_model_const]; +"528 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=528, type=symmetric_quantize]; +"529 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/conv2d_0" [id=529, type=conv2d]; +"530 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=530, type=symmetric_quantize]; +"531 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0" [id=531, type=cat]; +"532 dense3.10.bn1.weight" [id=532, type=nncf_model_const]; +"533 dense3.10.bn1.bias" [id=533, type=nncf_model_const]; +"534 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0" [id=534, type=batch_norm]; +"535 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_0" [id=535, type=relu]; +"536 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" [id=536, type=symmetric_quantize]; +"537 dense3.10.conv1.weight" [id=537, type=nncf_model_const]; +"538 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=538, type=symmetric_quantize]; +"539 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/conv2d_0" [id=539, type=conv2d]; +"540 dense3.10.bn2.weight" [id=540, type=nncf_model_const]; +"541 dense3.10.bn2.bias" [id=541, type=nncf_model_const]; +"542 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0" [id=542, type=batch_norm]; +"543 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_1" [id=543, type=relu]; +"544 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" [id=544, type=symmetric_quantize]; +"545 dense3.10.conv2.weight" [id=545, type=nncf_model_const]; +"546 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=546, type=symmetric_quantize]; +"547 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/conv2d_0" [id=547, type=conv2d]; +"548 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=548, type=symmetric_quantize]; +"549 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0" [id=549, type=cat]; +"550 dense3.11.bn1.weight" [id=550, type=nncf_model_const]; +"551 dense3.11.bn1.bias" [id=551, type=nncf_model_const]; +"552 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0" [id=552, type=batch_norm]; +"553 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_0" [id=553, type=relu]; +"554 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" [id=554, type=symmetric_quantize]; +"555 dense3.11.conv1.weight" [id=555, type=nncf_model_const]; +"556 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=556, type=symmetric_quantize]; +"557 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/conv2d_0" [id=557, type=conv2d]; +"558 dense3.11.bn2.weight" [id=558, type=nncf_model_const]; +"559 dense3.11.bn2.bias" [id=559, type=nncf_model_const]; +"560 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0" [id=560, type=batch_norm]; +"561 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_1" [id=561, type=relu]; +"562 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" [id=562, type=symmetric_quantize]; +"563 dense3.11.conv2.weight" [id=563, type=nncf_model_const]; +"564 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=564, type=symmetric_quantize]; +"565 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/conv2d_0" [id=565, type=conv2d]; +"566 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=566, type=symmetric_quantize]; +"567 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0" [id=567, type=cat]; +"568 dense3.12.bn1.weight" [id=568, type=nncf_model_const]; +"569 dense3.12.bn1.bias" [id=569, type=nncf_model_const]; +"570 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0" [id=570, type=batch_norm]; +"571 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_0" [id=571, type=relu]; +"572 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" [id=572, type=symmetric_quantize]; +"573 dense3.12.conv1.weight" [id=573, type=nncf_model_const]; +"574 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=574, type=symmetric_quantize]; +"575 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/conv2d_0" [id=575, type=conv2d]; +"576 dense3.12.bn2.weight" [id=576, type=nncf_model_const]; +"577 dense3.12.bn2.bias" [id=577, type=nncf_model_const]; +"578 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0" [id=578, type=batch_norm]; +"579 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_1" [id=579, type=relu]; +"580 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" [id=580, type=symmetric_quantize]; +"581 dense3.12.conv2.weight" [id=581, type=nncf_model_const]; +"582 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=582, type=symmetric_quantize]; +"583 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/conv2d_0" [id=583, type=conv2d]; +"584 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=584, type=symmetric_quantize]; +"585 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0" [id=585, type=cat]; +"586 dense3.13.bn1.weight" [id=586, type=nncf_model_const]; +"587 dense3.13.bn1.bias" [id=587, type=nncf_model_const]; +"588 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0" [id=588, type=batch_norm]; +"589 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_0" [id=589, type=relu]; +"590 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" [id=590, type=symmetric_quantize]; +"591 dense3.13.conv1.weight" [id=591, type=nncf_model_const]; +"592 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=592, type=symmetric_quantize]; +"593 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/conv2d_0" [id=593, type=conv2d]; +"594 dense3.13.bn2.weight" [id=594, type=nncf_model_const]; +"595 dense3.13.bn2.bias" [id=595, type=nncf_model_const]; +"596 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0" [id=596, type=batch_norm]; +"597 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_1" [id=597, type=relu]; +"598 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" [id=598, type=symmetric_quantize]; +"599 dense3.13.conv2.weight" [id=599, type=nncf_model_const]; +"600 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=600, type=symmetric_quantize]; +"601 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/conv2d_0" [id=601, type=conv2d]; +"602 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=602, type=symmetric_quantize]; +"603 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0" [id=603, type=cat]; +"604 dense3.14.bn1.weight" [id=604, type=nncf_model_const]; +"605 dense3.14.bn1.bias" [id=605, type=nncf_model_const]; +"606 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0" [id=606, type=batch_norm]; +"607 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_0" [id=607, type=relu]; +"608 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" [id=608, type=symmetric_quantize]; +"609 dense3.14.conv1.weight" [id=609, type=nncf_model_const]; +"610 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=610, type=symmetric_quantize]; +"611 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/conv2d_0" [id=611, type=conv2d]; +"612 dense3.14.bn2.weight" [id=612, type=nncf_model_const]; +"613 dense3.14.bn2.bias" [id=613, type=nncf_model_const]; +"614 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0" [id=614, type=batch_norm]; +"615 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_1" [id=615, type=relu]; +"616 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" [id=616, type=symmetric_quantize]; +"617 dense3.14.conv2.weight" [id=617, type=nncf_model_const]; +"618 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=618, type=symmetric_quantize]; +"619 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/conv2d_0" [id=619, type=conv2d]; +"620 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=620, type=symmetric_quantize]; +"621 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0" [id=621, type=cat]; +"622 dense3.15.bn1.weight" [id=622, type=nncf_model_const]; +"623 dense3.15.bn1.bias" [id=623, type=nncf_model_const]; +"624 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0" [id=624, type=batch_norm]; +"625 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_0" [id=625, type=relu]; +"626 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" [id=626, type=symmetric_quantize]; +"627 dense3.15.conv1.weight" [id=627, type=nncf_model_const]; +"628 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=628, type=symmetric_quantize]; +"629 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/conv2d_0" [id=629, type=conv2d]; +"630 dense3.15.bn2.weight" [id=630, type=nncf_model_const]; +"631 dense3.15.bn2.bias" [id=631, type=nncf_model_const]; +"632 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0" [id=632, type=batch_norm]; +"633 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_1" [id=633, type=relu]; +"634 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" [id=634, type=symmetric_quantize]; +"635 dense3.15.conv2.weight" [id=635, type=nncf_model_const]; +"636 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=636, type=symmetric_quantize]; +"637 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/conv2d_0" [id=637, type=conv2d]; +"638 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=638, type=symmetric_quantize]; +"639 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0" [id=639, type=cat]; +"640 dense3.16.bn1.weight" [id=640, type=nncf_model_const]; +"641 dense3.16.bn1.bias" [id=641, type=nncf_model_const]; +"642 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn1]/batch_norm_0" [id=642, type=batch_norm]; +"643 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_0" [id=643, type=relu]; +"644 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_0" [id=644, type=symmetric_quantize]; +"645 dense3.16.conv1.weight" [id=645, type=nncf_model_const]; +"646 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=646, type=symmetric_quantize]; +"647 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/conv2d_0" [id=647, type=conv2d]; +"648 dense3.16.bn2.weight" [id=648, type=nncf_model_const]; +"649 dense3.16.bn2.bias" [id=649, type=nncf_model_const]; +"650 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn2]/batch_norm_0" [id=650, type=batch_norm]; +"651 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_1" [id=651, type=relu]; +"652 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_1" [id=652, type=symmetric_quantize]; +"653 dense3.16.conv2.weight" [id=653, type=nncf_model_const]; +"654 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=654, type=symmetric_quantize]; +"655 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/conv2d_0" [id=655, type=conv2d]; +"656 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=656, type=symmetric_quantize]; +"657 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0" [id=657, type=cat]; +"658 dense3.17.bn1.weight" [id=658, type=nncf_model_const]; +"659 dense3.17.bn1.bias" [id=659, type=nncf_model_const]; +"660 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn1]/batch_norm_0" [id=660, type=batch_norm]; +"661 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_0" [id=661, type=relu]; +"662 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_0" [id=662, type=symmetric_quantize]; +"663 dense3.17.conv1.weight" [id=663, type=nncf_model_const]; +"664 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=664, type=symmetric_quantize]; +"665 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/conv2d_0" [id=665, type=conv2d]; +"666 dense3.17.bn2.weight" [id=666, type=nncf_model_const]; +"667 dense3.17.bn2.bias" [id=667, type=nncf_model_const]; +"668 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn2]/batch_norm_0" [id=668, type=batch_norm]; +"669 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_1" [id=669, type=relu]; +"670 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_1" [id=670, type=symmetric_quantize]; +"671 dense3.17.conv2.weight" [id=671, type=nncf_model_const]; +"672 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=672, type=symmetric_quantize]; +"673 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/conv2d_0" [id=673, type=conv2d]; +"674 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=674, type=symmetric_quantize]; +"675 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0" [id=675, type=cat]; +"676 dense3.18.bn1.weight" [id=676, type=nncf_model_const]; +"677 dense3.18.bn1.bias" [id=677, type=nncf_model_const]; +"678 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn1]/batch_norm_0" [id=678, type=batch_norm]; +"679 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_0" [id=679, type=relu]; +"680 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_0" [id=680, type=symmetric_quantize]; +"681 dense3.18.conv1.weight" [id=681, type=nncf_model_const]; +"682 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=682, type=symmetric_quantize]; +"683 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/conv2d_0" [id=683, type=conv2d]; +"684 dense3.18.bn2.weight" [id=684, type=nncf_model_const]; +"685 dense3.18.bn2.bias" [id=685, type=nncf_model_const]; +"686 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn2]/batch_norm_0" [id=686, type=batch_norm]; +"687 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_1" [id=687, type=relu]; +"688 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_1" [id=688, type=symmetric_quantize]; +"689 dense3.18.conv2.weight" [id=689, type=nncf_model_const]; +"690 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=690, type=symmetric_quantize]; +"691 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/conv2d_0" [id=691, type=conv2d]; +"692 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=692, type=symmetric_quantize]; +"693 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0" [id=693, type=cat]; +"694 dense3.19.bn1.weight" [id=694, type=nncf_model_const]; +"695 dense3.19.bn1.bias" [id=695, type=nncf_model_const]; +"696 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn1]/batch_norm_0" [id=696, type=batch_norm]; +"697 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_0" [id=697, type=relu]; +"698 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_0" [id=698, type=symmetric_quantize]; +"699 dense3.19.conv1.weight" [id=699, type=nncf_model_const]; +"700 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=700, type=symmetric_quantize]; +"701 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/conv2d_0" [id=701, type=conv2d]; +"702 dense3.19.bn2.weight" [id=702, type=nncf_model_const]; +"703 dense3.19.bn2.bias" [id=703, type=nncf_model_const]; +"704 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn2]/batch_norm_0" [id=704, type=batch_norm]; +"705 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_1" [id=705, type=relu]; +"706 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_1" [id=706, type=symmetric_quantize]; +"707 dense3.19.conv2.weight" [id=707, type=nncf_model_const]; +"708 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=708, type=symmetric_quantize]; +"709 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/conv2d_0" [id=709, type=conv2d]; +"710 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=710, type=symmetric_quantize]; +"711 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0" [id=711, type=cat]; +"712 dense3.20.bn1.weight" [id=712, type=nncf_model_const]; +"713 dense3.20.bn1.bias" [id=713, type=nncf_model_const]; +"714 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn1]/batch_norm_0" [id=714, type=batch_norm]; +"715 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_0" [id=715, type=relu]; +"716 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_0" [id=716, type=symmetric_quantize]; +"717 dense3.20.conv1.weight" [id=717, type=nncf_model_const]; +"718 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=718, type=symmetric_quantize]; +"719 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/conv2d_0" [id=719, type=conv2d]; +"720 dense3.20.bn2.weight" [id=720, type=nncf_model_const]; +"721 dense3.20.bn2.bias" [id=721, type=nncf_model_const]; +"722 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn2]/batch_norm_0" [id=722, type=batch_norm]; +"723 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_1" [id=723, type=relu]; +"724 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_1" [id=724, type=symmetric_quantize]; +"725 dense3.20.conv2.weight" [id=725, type=nncf_model_const]; +"726 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=726, type=symmetric_quantize]; +"727 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/conv2d_0" [id=727, type=conv2d]; +"728 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=728, type=symmetric_quantize]; +"729 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0" [id=729, type=cat]; +"730 dense3.21.bn1.weight" [id=730, type=nncf_model_const]; +"731 dense3.21.bn1.bias" [id=731, type=nncf_model_const]; +"732 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn1]/batch_norm_0" [id=732, type=batch_norm]; +"733 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_0" [id=733, type=relu]; +"734 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_0" [id=734, type=symmetric_quantize]; +"735 dense3.21.conv1.weight" [id=735, type=nncf_model_const]; +"736 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=736, type=symmetric_quantize]; +"737 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/conv2d_0" [id=737, type=conv2d]; +"738 dense3.21.bn2.weight" [id=738, type=nncf_model_const]; +"739 dense3.21.bn2.bias" [id=739, type=nncf_model_const]; +"740 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn2]/batch_norm_0" [id=740, type=batch_norm]; +"741 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_1" [id=741, type=relu]; +"742 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_1" [id=742, type=symmetric_quantize]; +"743 dense3.21.conv2.weight" [id=743, type=nncf_model_const]; +"744 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=744, type=symmetric_quantize]; +"745 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/conv2d_0" [id=745, type=conv2d]; +"746 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=746, type=symmetric_quantize]; +"747 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0" [id=747, type=cat]; +"748 dense3.22.bn1.weight" [id=748, type=nncf_model_const]; +"749 dense3.22.bn1.bias" [id=749, type=nncf_model_const]; +"750 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn1]/batch_norm_0" [id=750, type=batch_norm]; +"751 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_0" [id=751, type=relu]; +"752 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_0" [id=752, type=symmetric_quantize]; +"753 dense3.22.conv1.weight" [id=753, type=nncf_model_const]; +"754 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=754, type=symmetric_quantize]; +"755 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/conv2d_0" [id=755, type=conv2d]; +"756 dense3.22.bn2.weight" [id=756, type=nncf_model_const]; +"757 dense3.22.bn2.bias" [id=757, type=nncf_model_const]; +"758 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn2]/batch_norm_0" [id=758, type=batch_norm]; +"759 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_1" [id=759, type=relu]; +"760 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_1" [id=760, type=symmetric_quantize]; +"761 dense3.22.conv2.weight" [id=761, type=nncf_model_const]; +"762 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=762, type=symmetric_quantize]; +"763 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/conv2d_0" [id=763, type=conv2d]; +"764 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=764, type=symmetric_quantize]; +"765 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0" [id=765, type=cat]; +"766 dense3.23.bn1.weight" [id=766, type=nncf_model_const]; +"767 dense3.23.bn1.bias" [id=767, type=nncf_model_const]; +"768 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn1]/batch_norm_0" [id=768, type=batch_norm]; +"769 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_0" [id=769, type=relu]; +"770 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_0" [id=770, type=symmetric_quantize]; +"771 dense3.23.conv1.weight" [id=771, type=nncf_model_const]; +"772 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=772, type=symmetric_quantize]; +"773 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/conv2d_0" [id=773, type=conv2d]; +"774 dense3.23.bn2.weight" [id=774, type=nncf_model_const]; +"775 dense3.23.bn2.bias" [id=775, type=nncf_model_const]; +"776 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn2]/batch_norm_0" [id=776, type=batch_norm]; +"777 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_1" [id=777, type=relu]; +"778 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_1" [id=778, type=symmetric_quantize]; +"779 dense3.23.conv2.weight" [id=779, type=nncf_model_const]; +"780 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=780, type=symmetric_quantize]; +"781 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/conv2d_0" [id=781, type=conv2d]; +"782 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=782, type=symmetric_quantize]; +"783 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0" [id=783, type=cat]; +"784 trans3.bn.weight" [id=784, type=nncf_model_const]; +"785 trans3.bn.bias" [id=785, type=nncf_model_const]; +"786 DenseNet/Transition[trans3]/BatchNorm2d[bn]/batch_norm_0" [id=786, type=batch_norm]; +"787 DenseNet/Transition[trans3]/relu_0" [id=787, type=relu]; +"788 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_0" [id=788, type=symmetric_quantize]; +"789 trans3.conv.weight" [id=789, type=nncf_model_const]; +"790 DenseNet/Transition[trans3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=790, type=symmetric_quantize]; +"791 DenseNet/Transition[trans3]/Conv2d[conv]/conv2d_0" [id=791, type=conv2d]; +"792 DenseNet/Transition[trans3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" [id=792, type=symmetric_quantize]; +"793 DenseNet/Transition[trans3]/avg_pool2d_0" [id=793, type=avg_pool2d]; +"794 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1" [id=794, type=symmetric_quantize]; +"795 dense4.0.bn1.weight" [id=795, type=nncf_model_const]; +"796 dense4.0.bn1.bias" [id=796, type=nncf_model_const]; +"797 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=797, type=batch_norm]; +"798 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_0" [id=798, type=relu]; +"799 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=799, type=symmetric_quantize]; +"800 dense4.0.conv1.weight" [id=800, type=nncf_model_const]; +"801 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=801, type=symmetric_quantize]; +"802 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=802, type=conv2d]; +"803 dense4.0.bn2.weight" [id=803, type=nncf_model_const]; +"804 dense4.0.bn2.bias" [id=804, type=nncf_model_const]; +"805 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=805, type=batch_norm]; +"806 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_1" [id=806, type=relu]; +"807 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=807, type=symmetric_quantize]; +"808 dense4.0.conv2.weight" [id=808, type=nncf_model_const]; +"809 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=809, type=symmetric_quantize]; +"810 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=810, type=conv2d]; +"811 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=811, type=symmetric_quantize]; +"812 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0" [id=812, type=cat]; +"813 dense4.1.bn1.weight" [id=813, type=nncf_model_const]; +"814 dense4.1.bn1.bias" [id=814, type=nncf_model_const]; +"815 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=815, type=batch_norm]; +"816 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_0" [id=816, type=relu]; +"817 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=817, type=symmetric_quantize]; +"818 dense4.1.conv1.weight" [id=818, type=nncf_model_const]; +"819 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=819, type=symmetric_quantize]; +"820 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=820, type=conv2d]; +"821 dense4.1.bn2.weight" [id=821, type=nncf_model_const]; +"822 dense4.1.bn2.bias" [id=822, type=nncf_model_const]; +"823 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=823, type=batch_norm]; +"824 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_1" [id=824, type=relu]; +"825 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=825, type=symmetric_quantize]; +"826 dense4.1.conv2.weight" [id=826, type=nncf_model_const]; +"827 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=827, type=symmetric_quantize]; +"828 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=828, type=conv2d]; +"829 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=829, type=symmetric_quantize]; +"830 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0" [id=830, type=cat]; +"831 dense4.2.bn1.weight" [id=831, type=nncf_model_const]; +"832 dense4.2.bn1.bias" [id=832, type=nncf_model_const]; +"833 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=833, type=batch_norm]; +"834 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_0" [id=834, type=relu]; +"835 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=835, type=symmetric_quantize]; +"836 dense4.2.conv1.weight" [id=836, type=nncf_model_const]; +"837 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=837, type=symmetric_quantize]; +"838 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=838, type=conv2d]; +"839 dense4.2.bn2.weight" [id=839, type=nncf_model_const]; +"840 dense4.2.bn2.bias" [id=840, type=nncf_model_const]; +"841 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=841, type=batch_norm]; +"842 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_1" [id=842, type=relu]; +"843 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=843, type=symmetric_quantize]; +"844 dense4.2.conv2.weight" [id=844, type=nncf_model_const]; +"845 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=845, type=symmetric_quantize]; +"846 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=846, type=conv2d]; +"847 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=847, type=symmetric_quantize]; +"848 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0" [id=848, type=cat]; +"849 dense4.3.bn1.weight" [id=849, type=nncf_model_const]; +"850 dense4.3.bn1.bias" [id=850, type=nncf_model_const]; +"851 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" [id=851, type=batch_norm]; +"852 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_0" [id=852, type=relu]; +"853 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=853, type=symmetric_quantize]; +"854 dense4.3.conv1.weight" [id=854, type=nncf_model_const]; +"855 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=855, type=symmetric_quantize]; +"856 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" [id=856, type=conv2d]; +"857 dense4.3.bn2.weight" [id=857, type=nncf_model_const]; +"858 dense4.3.bn2.bias" [id=858, type=nncf_model_const]; +"859 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" [id=859, type=batch_norm]; +"860 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_1" [id=860, type=relu]; +"861 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=861, type=symmetric_quantize]; +"862 dense4.3.conv2.weight" [id=862, type=nncf_model_const]; +"863 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=863, type=symmetric_quantize]; +"864 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" [id=864, type=conv2d]; +"865 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=865, type=symmetric_quantize]; +"866 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0" [id=866, type=cat]; +"867 dense4.4.bn1.weight" [id=867, type=nncf_model_const]; +"868 dense4.4.bn1.bias" [id=868, type=nncf_model_const]; +"869 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" [id=869, type=batch_norm]; +"870 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_0" [id=870, type=relu]; +"871 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=871, type=symmetric_quantize]; +"872 dense4.4.conv1.weight" [id=872, type=nncf_model_const]; +"873 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=873, type=symmetric_quantize]; +"874 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" [id=874, type=conv2d]; +"875 dense4.4.bn2.weight" [id=875, type=nncf_model_const]; +"876 dense4.4.bn2.bias" [id=876, type=nncf_model_const]; +"877 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" [id=877, type=batch_norm]; +"878 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_1" [id=878, type=relu]; +"879 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=879, type=symmetric_quantize]; +"880 dense4.4.conv2.weight" [id=880, type=nncf_model_const]; +"881 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=881, type=symmetric_quantize]; +"882 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" [id=882, type=conv2d]; +"883 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=883, type=symmetric_quantize]; +"884 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0" [id=884, type=cat]; +"885 dense4.5.bn1.weight" [id=885, type=nncf_model_const]; +"886 dense4.5.bn1.bias" [id=886, type=nncf_model_const]; +"887 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" [id=887, type=batch_norm]; +"888 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_0" [id=888, type=relu]; +"889 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=889, type=symmetric_quantize]; +"890 dense4.5.conv1.weight" [id=890, type=nncf_model_const]; +"891 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=891, type=symmetric_quantize]; +"892 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" [id=892, type=conv2d]; +"893 dense4.5.bn2.weight" [id=893, type=nncf_model_const]; +"894 dense4.5.bn2.bias" [id=894, type=nncf_model_const]; +"895 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" [id=895, type=batch_norm]; +"896 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_1" [id=896, type=relu]; +"897 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=897, type=symmetric_quantize]; +"898 dense4.5.conv2.weight" [id=898, type=nncf_model_const]; +"899 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=899, type=symmetric_quantize]; +"900 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" [id=900, type=conv2d]; +"901 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=901, type=symmetric_quantize]; +"902 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0" [id=902, type=cat]; +"903 dense4.6.bn1.weight" [id=903, type=nncf_model_const]; +"904 dense4.6.bn1.bias" [id=904, type=nncf_model_const]; +"905 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0" [id=905, type=batch_norm]; +"906 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_0" [id=906, type=relu]; +"907 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" [id=907, type=symmetric_quantize]; +"908 dense4.6.conv1.weight" [id=908, type=nncf_model_const]; +"909 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=909, type=symmetric_quantize]; +"910 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/conv2d_0" [id=910, type=conv2d]; +"911 dense4.6.bn2.weight" [id=911, type=nncf_model_const]; +"912 dense4.6.bn2.bias" [id=912, type=nncf_model_const]; +"913 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0" [id=913, type=batch_norm]; +"914 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_1" [id=914, type=relu]; +"915 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" [id=915, type=symmetric_quantize]; +"916 dense4.6.conv2.weight" [id=916, type=nncf_model_const]; +"917 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=917, type=symmetric_quantize]; +"918 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/conv2d_0" [id=918, type=conv2d]; +"919 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=919, type=symmetric_quantize]; +"920 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0" [id=920, type=cat]; +"921 dense4.7.bn1.weight" [id=921, type=nncf_model_const]; +"922 dense4.7.bn1.bias" [id=922, type=nncf_model_const]; +"923 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0" [id=923, type=batch_norm]; +"924 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_0" [id=924, type=relu]; +"925 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" [id=925, type=symmetric_quantize]; +"926 dense4.7.conv1.weight" [id=926, type=nncf_model_const]; +"927 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=927, type=symmetric_quantize]; +"928 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/conv2d_0" [id=928, type=conv2d]; +"929 dense4.7.bn2.weight" [id=929, type=nncf_model_const]; +"930 dense4.7.bn2.bias" [id=930, type=nncf_model_const]; +"931 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0" [id=931, type=batch_norm]; +"932 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_1" [id=932, type=relu]; +"933 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" [id=933, type=symmetric_quantize]; +"934 dense4.7.conv2.weight" [id=934, type=nncf_model_const]; +"935 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=935, type=symmetric_quantize]; +"936 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/conv2d_0" [id=936, type=conv2d]; +"937 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=937, type=symmetric_quantize]; +"938 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0" [id=938, type=cat]; +"939 dense4.8.bn1.weight" [id=939, type=nncf_model_const]; +"940 dense4.8.bn1.bias" [id=940, type=nncf_model_const]; +"941 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0" [id=941, type=batch_norm]; +"942 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_0" [id=942, type=relu]; +"943 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" [id=943, type=symmetric_quantize]; +"944 dense4.8.conv1.weight" [id=944, type=nncf_model_const]; +"945 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=945, type=symmetric_quantize]; +"946 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/conv2d_0" [id=946, type=conv2d]; +"947 dense4.8.bn2.weight" [id=947, type=nncf_model_const]; +"948 dense4.8.bn2.bias" [id=948, type=nncf_model_const]; +"949 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0" [id=949, type=batch_norm]; +"950 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_1" [id=950, type=relu]; +"951 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" [id=951, type=symmetric_quantize]; +"952 dense4.8.conv2.weight" [id=952, type=nncf_model_const]; +"953 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=953, type=symmetric_quantize]; +"954 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/conv2d_0" [id=954, type=conv2d]; +"955 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=955, type=symmetric_quantize]; +"956 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0" [id=956, type=cat]; +"957 dense4.9.bn1.weight" [id=957, type=nncf_model_const]; +"958 dense4.9.bn1.bias" [id=958, type=nncf_model_const]; +"959 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0" [id=959, type=batch_norm]; +"960 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_0" [id=960, type=relu]; +"961 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" [id=961, type=symmetric_quantize]; +"962 dense4.9.conv1.weight" [id=962, type=nncf_model_const]; +"963 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=963, type=symmetric_quantize]; +"964 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/conv2d_0" [id=964, type=conv2d]; +"965 dense4.9.bn2.weight" [id=965, type=nncf_model_const]; +"966 dense4.9.bn2.bias" [id=966, type=nncf_model_const]; +"967 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0" [id=967, type=batch_norm]; +"968 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_1" [id=968, type=relu]; +"969 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" [id=969, type=symmetric_quantize]; +"970 dense4.9.conv2.weight" [id=970, type=nncf_model_const]; +"971 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=971, type=symmetric_quantize]; +"972 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/conv2d_0" [id=972, type=conv2d]; +"973 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=973, type=symmetric_quantize]; +"974 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0" [id=974, type=cat]; +"975 dense4.10.bn1.weight" [id=975, type=nncf_model_const]; +"976 dense4.10.bn1.bias" [id=976, type=nncf_model_const]; +"977 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0" [id=977, type=batch_norm]; +"978 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_0" [id=978, type=relu]; +"979 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" [id=979, type=symmetric_quantize]; +"980 dense4.10.conv1.weight" [id=980, type=nncf_model_const]; +"981 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=981, type=symmetric_quantize]; +"982 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/conv2d_0" [id=982, type=conv2d]; +"983 dense4.10.bn2.weight" [id=983, type=nncf_model_const]; +"984 dense4.10.bn2.bias" [id=984, type=nncf_model_const]; +"985 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0" [id=985, type=batch_norm]; +"986 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_1" [id=986, type=relu]; +"987 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" [id=987, type=symmetric_quantize]; +"988 dense4.10.conv2.weight" [id=988, type=nncf_model_const]; +"989 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=989, type=symmetric_quantize]; +"990 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/conv2d_0" [id=990, type=conv2d]; +"991 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=991, type=symmetric_quantize]; +"992 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0" [id=992, type=cat]; +"993 dense4.11.bn1.weight" [id=993, type=nncf_model_const]; +"994 dense4.11.bn1.bias" [id=994, type=nncf_model_const]; +"995 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0" [id=995, type=batch_norm]; +"996 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_0" [id=996, type=relu]; +"997 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" [id=997, type=symmetric_quantize]; +"998 dense4.11.conv1.weight" [id=998, type=nncf_model_const]; +"999 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=999, type=symmetric_quantize]; +"1000 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/conv2d_0" [id=1000, type=conv2d]; +"1001 dense4.11.bn2.weight" [id=1001, type=nncf_model_const]; +"1002 dense4.11.bn2.bias" [id=1002, type=nncf_model_const]; +"1003 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0" [id=1003, type=batch_norm]; +"1004 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_1" [id=1004, type=relu]; +"1005 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" [id=1005, type=symmetric_quantize]; +"1006 dense4.11.conv2.weight" [id=1006, type=nncf_model_const]; +"1007 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=1007, type=symmetric_quantize]; +"1008 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/conv2d_0" [id=1008, type=conv2d]; +"1009 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=1009, type=symmetric_quantize]; +"1010 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0" [id=1010, type=cat]; +"1011 dense4.12.bn1.weight" [id=1011, type=nncf_model_const]; +"1012 dense4.12.bn1.bias" [id=1012, type=nncf_model_const]; +"1013 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0" [id=1013, type=batch_norm]; +"1014 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_0" [id=1014, type=relu]; +"1015 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" [id=1015, type=symmetric_quantize]; +"1016 dense4.12.conv1.weight" [id=1016, type=nncf_model_const]; +"1017 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=1017, type=symmetric_quantize]; +"1018 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/conv2d_0" [id=1018, type=conv2d]; +"1019 dense4.12.bn2.weight" [id=1019, type=nncf_model_const]; +"1020 dense4.12.bn2.bias" [id=1020, type=nncf_model_const]; +"1021 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0" [id=1021, type=batch_norm]; +"1022 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_1" [id=1022, type=relu]; +"1023 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" [id=1023, type=symmetric_quantize]; +"1024 dense4.12.conv2.weight" [id=1024, type=nncf_model_const]; +"1025 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=1025, type=symmetric_quantize]; +"1026 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/conv2d_0" [id=1026, type=conv2d]; +"1027 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=1027, type=symmetric_quantize]; +"1028 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0" [id=1028, type=cat]; +"1029 dense4.13.bn1.weight" [id=1029, type=nncf_model_const]; +"1030 dense4.13.bn1.bias" [id=1030, type=nncf_model_const]; +"1031 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0" [id=1031, type=batch_norm]; +"1032 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_0" [id=1032, type=relu]; +"1033 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" [id=1033, type=symmetric_quantize]; +"1034 dense4.13.conv1.weight" [id=1034, type=nncf_model_const]; +"1035 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=1035, type=symmetric_quantize]; +"1036 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/conv2d_0" [id=1036, type=conv2d]; +"1037 dense4.13.bn2.weight" [id=1037, type=nncf_model_const]; +"1038 dense4.13.bn2.bias" [id=1038, type=nncf_model_const]; +"1039 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0" [id=1039, type=batch_norm]; +"1040 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_1" [id=1040, type=relu]; +"1041 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" [id=1041, type=symmetric_quantize]; +"1042 dense4.13.conv2.weight" [id=1042, type=nncf_model_const]; +"1043 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=1043, type=symmetric_quantize]; +"1044 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/conv2d_0" [id=1044, type=conv2d]; +"1045 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=1045, type=symmetric_quantize]; +"1046 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0" [id=1046, type=cat]; +"1047 dense4.14.bn1.weight" [id=1047, type=nncf_model_const]; +"1048 dense4.14.bn1.bias" [id=1048, type=nncf_model_const]; +"1049 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0" [id=1049, type=batch_norm]; +"1050 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_0" [id=1050, type=relu]; +"1051 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" [id=1051, type=symmetric_quantize]; +"1052 dense4.14.conv1.weight" [id=1052, type=nncf_model_const]; +"1053 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=1053, type=symmetric_quantize]; +"1054 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/conv2d_0" [id=1054, type=conv2d]; +"1055 dense4.14.bn2.weight" [id=1055, type=nncf_model_const]; +"1056 dense4.14.bn2.bias" [id=1056, type=nncf_model_const]; +"1057 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0" [id=1057, type=batch_norm]; +"1058 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_1" [id=1058, type=relu]; +"1059 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" [id=1059, type=symmetric_quantize]; +"1060 dense4.14.conv2.weight" [id=1060, type=nncf_model_const]; +"1061 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=1061, type=symmetric_quantize]; +"1062 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/conv2d_0" [id=1062, type=conv2d]; +"1063 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=1063, type=symmetric_quantize]; +"1064 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0" [id=1064, type=cat]; +"1065 dense4.15.bn1.weight" [id=1065, type=nncf_model_const]; +"1066 dense4.15.bn1.bias" [id=1066, type=nncf_model_const]; +"1067 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0" [id=1067, type=batch_norm]; +"1068 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_0" [id=1068, type=relu]; +"1069 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" [id=1069, type=symmetric_quantize]; +"1070 dense4.15.conv1.weight" [id=1070, type=nncf_model_const]; +"1071 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=1071, type=symmetric_quantize]; +"1072 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/conv2d_0" [id=1072, type=conv2d]; +"1073 dense4.15.bn2.weight" [id=1073, type=nncf_model_const]; +"1074 dense4.15.bn2.bias" [id=1074, type=nncf_model_const]; +"1075 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0" [id=1075, type=batch_norm]; +"1076 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_1" [id=1076, type=relu]; +"1077 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" [id=1077, type=symmetric_quantize]; +"1078 dense4.15.conv2.weight" [id=1078, type=nncf_model_const]; +"1079 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=1079, type=symmetric_quantize]; +"1080 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/conv2d_0" [id=1080, type=conv2d]; +"1081 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" [id=1081, type=symmetric_quantize]; +"1082 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0" [id=1082, type=cat]; +"1083 bn.weight" [id=1083, type=nncf_model_const]; +"1084 bn.bias" [id=1084, type=nncf_model_const]; +"1085 DenseNet/BatchNorm2d[bn]/batch_norm_0" [id=1085, type=batch_norm]; +"1086 DenseNet/relu_0" [id=1086, type=relu]; +"1087 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=1087, type=symmetric_quantize]; +"1088 DenseNet/avg_pool2d_0" [id=1088, type=avg_pool2d]; +"1089 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=1089, type=symmetric_quantize]; +"1090 DenseNet/view_0" [id=1090, type=view]; +"1091 linear.weight" [id=1091, type=nncf_model_const]; +"1092 linear.bias" [id=1092, type=nncf_model_const]; +"1093 DenseNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" [id=1093, type=symmetric_quantize]; +"1094 DenseNet/Linear[linear]/linear_0" [id=1094, type=linear]; +"1095 /nncf_model_output_0" [id=1095, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 DenseNet/NNCFConv2d[conv1]/conv2d_0"; -"2 DenseNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 DenseNet/NNCFConv2d[conv1]/conv2d_0"; -"3 DenseNet/NNCFConv2d[conv1]/conv2d_0" -> "4 DenseNet/NNCFConv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; -"4 DenseNet/NNCFConv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "5 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"4 DenseNet/NNCFConv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "16 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0"; -"5 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "6 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_0"; -"6 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_0" -> "7 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"7 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "9 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"8 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "9 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"9 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "10 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"10 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "11 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_1"; -"11 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_1" -> "12 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"12 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "14 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"13 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"14 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "15 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"15 DenseNet/Sequential[dense1]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "16 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0"; -"16 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0" -> "17 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"16 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0" -> "28 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0"; -"17 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "18 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_0"; -"18 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_0" -> "19 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"19 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "21 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"20 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"21 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "22 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"22 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "23 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_1"; -"23 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_1" -> "24 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"24 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "26 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"25 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "26 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"26 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "27 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"27 DenseNet/Sequential[dense1]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "28 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0"; -"28 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0" -> "29 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"28 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0" -> "40 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0"; -"29 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "30 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_0"; -"30 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_0" -> "31 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"31 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "33 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"32 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "33 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"33 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "34 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"34 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "35 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_1"; -"35 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_1" -> "36 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"36 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "38 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"37 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "38 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"38 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "39 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"39 DenseNet/Sequential[dense1]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "40 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0"; -"40 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0" -> "41 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"40 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0" -> "52 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0"; -"41 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "42 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_0"; -"42 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_0" -> "43 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; -"43 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "45 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"44 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "45 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"45 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "46 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"46 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "47 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_1"; -"47 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_1" -> "48 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; -"48 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "50 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"49 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "50 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"50 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "51 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"51 DenseNet/Sequential[dense1]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "52 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0"; -"52 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0" -> "53 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"52 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0" -> "64 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0"; -"53 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "54 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_0"; -"54 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_0" -> "55 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; -"55 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "57 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"56 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"57 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "58 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"58 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "59 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_1"; -"59 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_1" -> "60 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; -"60 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "62 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"61 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"62 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "63 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"63 DenseNet/Sequential[dense1]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "64 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0"; -"64 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0" -> "65 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"64 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0" -> "76 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0"; -"65 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "66 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_0"; -"66 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_0" -> "67 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; -"67 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "69 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"68 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "69 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"69 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "70 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"70 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "71 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_1"; -"71 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_1" -> "72 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; -"72 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "74 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"73 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "74 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"74 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "75 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"75 DenseNet/Sequential[dense1]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "76 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0"; -"76 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0" -> "77 DenseNet/Transition[trans1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"77 DenseNet/Transition[trans1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "78 DenseNet/Transition[trans1]/relu_0"; -"78 DenseNet/Transition[trans1]/relu_0" -> "79 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_0"; -"79 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_0" -> "81 DenseNet/Transition[trans1]/NNCFConv2d[conv]/conv2d_0"; -"80 DenseNet/Transition[trans1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "81 DenseNet/Transition[trans1]/NNCFConv2d[conv]/conv2d_0"; -"81 DenseNet/Transition[trans1]/NNCFConv2d[conv]/conv2d_0" -> "82 DenseNet/Transition[trans1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; -"82 DenseNet/Transition[trans1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "83 DenseNet/Transition[trans1]/avg_pool2d_0"; -"83 DenseNet/Transition[trans1]/avg_pool2d_0" -> "84 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1"; -"84 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1" -> "85 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"84 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1" -> "96 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0"; -"85 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "86 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_0"; -"86 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_0" -> "87 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"87 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "89 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"88 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "89 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"89 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "90 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"90 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "91 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_1"; -"91 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_1" -> "92 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"92 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "94 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"93 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "94 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"94 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "95 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"95 DenseNet/Sequential[dense2]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "96 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0"; -"96 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0" -> "97 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"96 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0" -> "108 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0"; -"97 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "98 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_0"; -"98 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_0" -> "99 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"99 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "101 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"100 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "101 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"101 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "102 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"102 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "103 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_1"; -"103 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_1" -> "104 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"104 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "106 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"105 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "106 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"106 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "107 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"107 DenseNet/Sequential[dense2]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "108 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0"; -"108 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0" -> "109 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"108 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0" -> "120 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0"; -"109 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "110 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_0"; -"110 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_0" -> "111 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"111 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "113 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"112 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "113 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"113 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "114 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"114 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "115 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_1"; -"115 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_1" -> "116 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"116 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "118 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"117 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "118 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"118 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "119 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"119 DenseNet/Sequential[dense2]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "120 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0"; -"120 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0" -> "121 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"120 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0" -> "132 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0"; -"121 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "122 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_0"; -"122 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_0" -> "123 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; -"123 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "125 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"124 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "125 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"125 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "126 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"126 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "127 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_1"; -"127 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_1" -> "128 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; -"128 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "130 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"129 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "130 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"130 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "131 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"131 DenseNet/Sequential[dense2]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "132 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0"; -"132 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0" -> "133 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"132 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0" -> "144 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0"; -"133 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "134 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_0"; -"134 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_0" -> "135 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; -"135 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "137 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"136 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "137 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"137 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "138 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"138 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "139 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_1"; -"139 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_1" -> "140 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; -"140 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "142 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"141 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "142 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"142 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "143 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"143 DenseNet/Sequential[dense2]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "144 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0"; -"144 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0" -> "145 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"144 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0" -> "156 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0"; -"145 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "146 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_0"; -"146 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_0" -> "147 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; -"147 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "149 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"148 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"149 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "150 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"150 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "151 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_1"; -"151 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_1" -> "152 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; -"152 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "154 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"153 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "154 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"154 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "155 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"155 DenseNet/Sequential[dense2]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "156 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0"; -"156 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0" -> "157 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"156 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0" -> "168 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0"; -"157 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "158 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_0"; -"158 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_0" -> "159 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0"; -"159 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" -> "161 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0"; -"160 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "161 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0"; -"161 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0" -> "162 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"162 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "163 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_1"; -"163 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_1" -> "164 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1"; -"164 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" -> "166 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0"; -"165 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "166 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0"; -"166 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0" -> "167 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"167 DenseNet/Sequential[dense2]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "168 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0"; -"168 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0" -> "169 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"168 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0" -> "180 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0"; -"169 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "170 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_0"; -"170 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_0" -> "171 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0"; -"171 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" -> "173 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0"; -"172 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "173 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0"; -"173 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0" -> "174 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"174 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "175 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_1"; -"175 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_1" -> "176 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1"; -"176 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" -> "178 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0"; -"177 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "178 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0"; -"178 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0" -> "179 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"179 DenseNet/Sequential[dense2]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "180 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0"; -"180 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0" -> "181 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"180 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0" -> "192 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0"; -"181 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "182 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_0"; -"182 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_0" -> "183 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0"; -"183 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" -> "185 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0"; -"184 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "185 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0"; -"185 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0" -> "186 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"186 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "187 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_1"; -"187 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_1" -> "188 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1"; -"188 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" -> "190 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0"; -"189 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "190 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0"; -"190 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0" -> "191 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"191 DenseNet/Sequential[dense2]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "192 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0"; -"192 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0" -> "193 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"192 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0" -> "204 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0"; -"193 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "194 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_0"; -"194 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_0" -> "195 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0"; -"195 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" -> "197 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0"; -"196 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "197 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0"; -"197 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0" -> "198 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"198 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "199 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_1"; -"199 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_1" -> "200 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1"; -"200 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" -> "202 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0"; -"201 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "202 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0"; -"202 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0" -> "203 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"203 DenseNet/Sequential[dense2]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "204 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0"; -"204 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0" -> "205 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"204 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0" -> "216 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0"; -"205 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "206 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_0"; -"206 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_0" -> "207 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0"; -"207 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" -> "209 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0"; -"208 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "209 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0"; -"209 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0" -> "210 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"210 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "211 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_1"; -"211 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_1" -> "212 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1"; -"212 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" -> "214 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0"; -"213 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "214 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0"; -"214 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0" -> "215 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"215 DenseNet/Sequential[dense2]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "216 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0"; -"216 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0" -> "217 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"216 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0" -> "228 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0"; -"217 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "218 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_0"; -"218 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_0" -> "219 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0"; -"219 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" -> "221 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0"; -"220 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "221 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0"; -"221 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0" -> "222 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"222 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "223 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_1"; -"223 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_1" -> "224 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1"; -"224 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" -> "226 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0"; -"225 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "226 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0"; -"226 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0" -> "227 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"227 DenseNet/Sequential[dense2]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "228 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0"; -"228 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0" -> "229 DenseNet/Transition[trans2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"229 DenseNet/Transition[trans2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "230 DenseNet/Transition[trans2]/relu_0"; -"230 DenseNet/Transition[trans2]/relu_0" -> "231 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_0"; -"231 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_0" -> "233 DenseNet/Transition[trans2]/NNCFConv2d[conv]/conv2d_0"; -"232 DenseNet/Transition[trans2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "233 DenseNet/Transition[trans2]/NNCFConv2d[conv]/conv2d_0"; -"233 DenseNet/Transition[trans2]/NNCFConv2d[conv]/conv2d_0" -> "234 DenseNet/Transition[trans2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; -"234 DenseNet/Transition[trans2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "235 DenseNet/Transition[trans2]/avg_pool2d_0"; -"235 DenseNet/Transition[trans2]/avg_pool2d_0" -> "236 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1"; -"236 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1" -> "237 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"236 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1" -> "248 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0"; -"237 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "238 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_0"; -"238 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_0" -> "239 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"239 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "241 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"240 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "241 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"241 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "242 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"242 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "243 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_1"; -"243 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_1" -> "244 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"244 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "246 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"245 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "246 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"246 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "247 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"247 DenseNet/Sequential[dense3]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "248 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0"; -"248 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0" -> "249 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"248 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0" -> "260 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0"; -"249 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "250 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_0"; -"250 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_0" -> "251 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"251 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "253 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"252 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "253 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"253 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "254 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"254 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "255 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_1"; -"255 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_1" -> "256 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"256 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "258 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"257 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "258 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"258 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "259 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"259 DenseNet/Sequential[dense3]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "260 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0"; -"260 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0" -> "261 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"260 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0" -> "272 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0"; -"261 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "262 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_0"; -"262 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_0" -> "263 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"263 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "265 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"264 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "265 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"265 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "266 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"266 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "267 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_1"; -"267 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_1" -> "268 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"268 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "270 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"269 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "270 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"270 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "271 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"271 DenseNet/Sequential[dense3]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "272 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0"; -"272 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0" -> "273 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"272 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0" -> "284 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0"; -"273 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "274 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_0"; -"274 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_0" -> "275 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; -"275 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "277 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"276 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "277 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"277 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "278 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"278 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "279 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_1"; -"279 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_1" -> "280 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; -"280 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "282 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"281 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "282 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"282 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "283 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"283 DenseNet/Sequential[dense3]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "284 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0"; -"284 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0" -> "285 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"284 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0" -> "296 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0"; -"285 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "286 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_0"; -"286 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_0" -> "287 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; -"287 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "289 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"288 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "289 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"289 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "290 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"290 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "291 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_1"; -"291 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_1" -> "292 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; -"292 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "294 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"293 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "294 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"294 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "295 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"295 DenseNet/Sequential[dense3]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "296 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0"; -"296 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0" -> "297 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"296 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0" -> "308 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0"; -"297 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "298 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_0"; -"298 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_0" -> "299 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; -"299 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "301 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"300 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "301 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"301 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "302 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"302 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "303 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_1"; -"303 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_1" -> "304 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; -"304 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "306 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"305 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "306 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"306 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "307 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"307 DenseNet/Sequential[dense3]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "308 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0"; -"308 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0" -> "309 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"308 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0" -> "320 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0"; -"309 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "310 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_0"; -"310 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_0" -> "311 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0"; -"311 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" -> "313 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0"; -"312 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "313 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0"; -"313 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0" -> "314 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"314 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "315 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_1"; -"315 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_1" -> "316 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1"; -"316 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" -> "318 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0"; -"317 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "318 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0"; -"318 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0" -> "319 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"319 DenseNet/Sequential[dense3]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "320 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0"; -"320 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0" -> "321 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"320 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0" -> "332 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0"; -"321 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "322 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_0"; -"322 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_0" -> "323 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0"; -"323 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" -> "325 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0"; -"324 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "325 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0"; -"325 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0" -> "326 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"326 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "327 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_1"; -"327 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_1" -> "328 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1"; -"328 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" -> "330 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0"; -"329 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "330 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0"; -"330 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0" -> "331 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"331 DenseNet/Sequential[dense3]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "332 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0"; -"332 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0" -> "333 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"332 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0" -> "344 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0"; -"333 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "334 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_0"; -"334 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_0" -> "335 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0"; -"335 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" -> "337 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0"; -"336 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "337 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0"; -"337 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0" -> "338 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"338 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "339 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_1"; -"339 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_1" -> "340 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1"; -"340 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" -> "342 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0"; -"341 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "342 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0"; -"342 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0" -> "343 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"343 DenseNet/Sequential[dense3]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "344 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0"; -"344 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0" -> "345 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"344 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0" -> "356 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0"; -"345 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "346 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_0"; -"346 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_0" -> "347 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0"; -"347 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" -> "349 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0"; -"348 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "349 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0"; -"349 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0" -> "350 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"350 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "351 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_1"; -"351 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_1" -> "352 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1"; -"352 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" -> "354 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0"; -"353 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "354 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0"; -"354 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0" -> "355 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"355 DenseNet/Sequential[dense3]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "356 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0"; -"356 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0" -> "357 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"356 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0" -> "368 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0"; -"357 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "358 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_0"; -"358 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_0" -> "359 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0"; -"359 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" -> "361 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0"; -"360 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "361 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0"; -"361 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0" -> "362 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"362 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "363 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_1"; -"363 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_1" -> "364 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1"; -"364 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" -> "366 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0"; -"365 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "366 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0"; -"366 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0" -> "367 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"367 DenseNet/Sequential[dense3]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "368 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0"; -"368 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0" -> "369 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"368 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0" -> "380 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0"; -"369 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "370 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_0"; -"370 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_0" -> "371 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0"; -"371 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" -> "373 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0"; -"372 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "373 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0"; -"373 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0" -> "374 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"374 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "375 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_1"; -"375 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_1" -> "376 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1"; -"376 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" -> "378 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0"; -"377 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "378 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0"; -"378 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0" -> "379 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"379 DenseNet/Sequential[dense3]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "380 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0"; -"380 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0" -> "381 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"380 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0" -> "392 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0"; -"381 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "382 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_0"; -"382 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_0" -> "383 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0"; -"383 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" -> "385 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0"; -"384 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "385 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0"; -"385 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0" -> "386 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"386 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "387 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_1"; -"387 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_1" -> "388 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1"; -"388 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" -> "390 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0"; -"389 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "390 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0"; -"390 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0" -> "391 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"391 DenseNet/Sequential[dense3]/Bottleneck[12]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "392 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0"; -"392 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0" -> "393 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"392 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0" -> "404 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0"; -"393 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "394 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_0"; -"394 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_0" -> "395 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0"; -"395 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" -> "397 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0"; -"396 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "397 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0"; -"397 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0" -> "398 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"398 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "399 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_1"; -"399 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_1" -> "400 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1"; -"400 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" -> "402 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0"; -"401 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "402 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0"; -"402 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0" -> "403 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"403 DenseNet/Sequential[dense3]/Bottleneck[13]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "404 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0"; -"404 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0" -> "405 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"404 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0" -> "416 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0"; -"405 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "406 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_0"; -"406 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_0" -> "407 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0"; -"407 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" -> "409 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0"; -"408 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "409 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0"; -"409 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0" -> "410 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"410 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "411 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_1"; -"411 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_1" -> "412 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1"; -"412 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" -> "414 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0"; -"413 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "414 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0"; -"414 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0" -> "415 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"415 DenseNet/Sequential[dense3]/Bottleneck[14]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "416 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0"; -"416 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0" -> "417 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"416 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0" -> "428 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0"; -"417 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "418 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_0"; -"418 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_0" -> "419 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0"; -"419 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" -> "421 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0"; -"420 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "421 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0"; -"421 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0" -> "422 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"422 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "423 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_1"; -"423 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_1" -> "424 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1"; -"424 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" -> "426 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0"; -"425 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "426 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0"; -"426 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0" -> "427 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"427 DenseNet/Sequential[dense3]/Bottleneck[15]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "428 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0"; -"428 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0" -> "429 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"428 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0" -> "440 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0"; -"429 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "430 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_0"; -"430 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_0" -> "431 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_0"; -"431 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_0" -> "433 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv1]/conv2d_0"; -"432 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "433 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv1]/conv2d_0"; -"433 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv1]/conv2d_0" -> "434 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"434 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "435 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_1"; -"435 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_1" -> "436 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_1"; -"436 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_1" -> "438 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/conv2d_0"; -"437 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "438 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/conv2d_0"; -"438 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/conv2d_0" -> "439 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"439 DenseNet/Sequential[dense3]/Bottleneck[16]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "440 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0"; -"440 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0" -> "441 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"440 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0" -> "452 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0"; -"441 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "442 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_0"; -"442 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_0" -> "443 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_0"; -"443 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_0" -> "445 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv1]/conv2d_0"; -"444 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "445 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv1]/conv2d_0"; -"445 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv1]/conv2d_0" -> "446 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"446 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "447 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_1"; -"447 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_1" -> "448 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_1"; -"448 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_1" -> "450 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/conv2d_0"; -"449 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "450 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/conv2d_0"; -"450 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/conv2d_0" -> "451 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"451 DenseNet/Sequential[dense3]/Bottleneck[17]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "452 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0"; -"452 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0" -> "453 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"452 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0" -> "464 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0"; -"453 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "454 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_0"; -"454 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_0" -> "455 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_0"; -"455 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_0" -> "457 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv1]/conv2d_0"; -"456 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "457 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv1]/conv2d_0"; -"457 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv1]/conv2d_0" -> "458 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"458 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "459 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_1"; -"459 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_1" -> "460 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_1"; -"460 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_1" -> "462 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/conv2d_0"; -"461 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "462 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/conv2d_0"; -"462 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/conv2d_0" -> "463 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"463 DenseNet/Sequential[dense3]/Bottleneck[18]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "464 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0"; -"464 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0" -> "465 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"464 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0" -> "476 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0"; -"465 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "466 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_0"; -"466 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_0" -> "467 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_0"; -"467 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_0" -> "469 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv1]/conv2d_0"; -"468 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "469 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv1]/conv2d_0"; -"469 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv1]/conv2d_0" -> "470 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"470 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "471 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_1"; -"471 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_1" -> "472 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_1"; -"472 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_1" -> "474 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/conv2d_0"; -"473 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "474 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/conv2d_0"; -"474 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/conv2d_0" -> "475 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"475 DenseNet/Sequential[dense3]/Bottleneck[19]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "476 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0"; -"476 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0" -> "477 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"476 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0" -> "488 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0"; -"477 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "478 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_0"; -"478 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_0" -> "479 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_0"; -"479 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_0" -> "481 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv1]/conv2d_0"; -"480 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "481 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv1]/conv2d_0"; -"481 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv1]/conv2d_0" -> "482 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"482 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "483 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_1"; -"483 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_1" -> "484 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_1"; -"484 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_1" -> "486 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/conv2d_0"; -"485 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "486 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/conv2d_0"; -"486 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/conv2d_0" -> "487 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"487 DenseNet/Sequential[dense3]/Bottleneck[20]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "488 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0"; -"488 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0" -> "489 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"488 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0" -> "500 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0"; -"489 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "490 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_0"; -"490 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_0" -> "491 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_0"; -"491 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_0" -> "493 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv1]/conv2d_0"; -"492 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "493 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv1]/conv2d_0"; -"493 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv1]/conv2d_0" -> "494 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"494 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "495 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_1"; -"495 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_1" -> "496 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_1"; -"496 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_1" -> "498 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/conv2d_0"; -"497 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "498 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/conv2d_0"; -"498 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/conv2d_0" -> "499 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"499 DenseNet/Sequential[dense3]/Bottleneck[21]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "500 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0"; -"500 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0" -> "501 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"500 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0" -> "512 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0"; -"501 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "502 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_0"; -"502 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_0" -> "503 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_0"; -"503 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_0" -> "505 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv1]/conv2d_0"; -"504 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "505 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv1]/conv2d_0"; -"505 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv1]/conv2d_0" -> "506 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"506 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "507 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_1"; -"507 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_1" -> "508 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_1"; -"508 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_1" -> "510 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/conv2d_0"; -"509 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "510 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/conv2d_0"; -"510 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/conv2d_0" -> "511 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"511 DenseNet/Sequential[dense3]/Bottleneck[22]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "512 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0"; -"512 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0" -> "513 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"512 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0" -> "524 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0"; -"513 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "514 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_0"; -"514 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_0" -> "515 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_0"; -"515 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_0" -> "517 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv1]/conv2d_0"; -"516 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "517 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv1]/conv2d_0"; -"517 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv1]/conv2d_0" -> "518 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"518 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "519 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_1"; -"519 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_1" -> "520 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_1"; -"520 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_1" -> "522 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/conv2d_0"; -"521 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "522 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/conv2d_0"; -"522 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/conv2d_0" -> "523 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"523 DenseNet/Sequential[dense3]/Bottleneck[23]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "524 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0"; -"524 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0" -> "525 DenseNet/Transition[trans3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"525 DenseNet/Transition[trans3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "526 DenseNet/Transition[trans3]/relu_0"; -"526 DenseNet/Transition[trans3]/relu_0" -> "527 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_0"; -"527 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_0" -> "529 DenseNet/Transition[trans3]/NNCFConv2d[conv]/conv2d_0"; -"528 DenseNet/Transition[trans3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "529 DenseNet/Transition[trans3]/NNCFConv2d[conv]/conv2d_0"; -"529 DenseNet/Transition[trans3]/NNCFConv2d[conv]/conv2d_0" -> "530 DenseNet/Transition[trans3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; -"530 DenseNet/Transition[trans3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "531 DenseNet/Transition[trans3]/avg_pool2d_0"; -"531 DenseNet/Transition[trans3]/avg_pool2d_0" -> "532 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1"; -"532 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1" -> "533 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"532 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1" -> "544 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0"; -"533 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "534 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_0"; -"534 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_0" -> "535 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"535 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "537 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"536 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "537 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"537 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "538 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"538 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "539 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_1"; -"539 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_1" -> "540 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"540 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "542 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"541 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "542 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"542 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "543 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"543 DenseNet/Sequential[dense4]/Bottleneck[0]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "544 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0"; -"544 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0" -> "545 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"544 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0" -> "556 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0"; -"545 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "546 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_0"; -"546 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_0" -> "547 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"547 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "549 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"548 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "549 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"549 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "550 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"550 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "551 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_1"; -"551 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_1" -> "552 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"552 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "554 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"553 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "554 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"554 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "555 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"555 DenseNet/Sequential[dense4]/Bottleneck[1]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "556 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0"; -"556 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0" -> "557 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"556 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0" -> "568 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0"; -"557 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "558 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_0"; -"558 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_0" -> "559 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"559 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "561 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"560 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "561 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"561 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "562 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"562 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "563 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_1"; -"563 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_1" -> "564 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"564 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "566 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"565 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "566 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"566 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "567 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"567 DenseNet/Sequential[dense4]/Bottleneck[2]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "568 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0"; -"568 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0" -> "569 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"568 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0" -> "580 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0"; -"569 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "570 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_0"; -"570 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_0" -> "571 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; -"571 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "573 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"572 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "573 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"573 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "574 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"574 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "575 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_1"; -"575 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_1" -> "576 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; -"576 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "578 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"577 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "578 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"578 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "579 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"579 DenseNet/Sequential[dense4]/Bottleneck[3]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "580 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0"; -"580 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0" -> "581 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"580 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0" -> "592 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0"; -"581 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "582 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_0"; -"582 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_0" -> "583 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; -"583 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "585 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"584 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "585 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"585 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "586 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"586 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "587 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_1"; -"587 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_1" -> "588 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; -"588 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "590 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"589 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "590 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"590 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "591 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"591 DenseNet/Sequential[dense4]/Bottleneck[4]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "592 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0"; -"592 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0" -> "593 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"592 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0" -> "604 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0"; -"593 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "594 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_0"; -"594 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_0" -> "595 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; -"595 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "597 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"596 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "597 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"597 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "598 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"598 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "599 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_1"; -"599 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_1" -> "600 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; -"600 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "602 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"601 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "602 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"602 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "603 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"603 DenseNet/Sequential[dense4]/Bottleneck[5]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "604 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0"; -"604 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0" -> "605 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"604 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0" -> "616 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0"; -"605 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "606 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_0"; -"606 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_0" -> "607 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0"; -"607 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" -> "609 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0"; -"608 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "609 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0"; -"609 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv1]/conv2d_0" -> "610 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"610 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "611 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_1"; -"611 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_1" -> "612 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1"; -"612 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" -> "614 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0"; -"613 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "614 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0"; -"614 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/conv2d_0" -> "615 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"615 DenseNet/Sequential[dense4]/Bottleneck[6]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "616 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0"; -"616 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0" -> "617 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"616 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0" -> "628 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0"; -"617 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "618 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_0"; -"618 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_0" -> "619 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0"; -"619 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" -> "621 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0"; -"620 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "621 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0"; -"621 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv1]/conv2d_0" -> "622 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"622 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "623 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_1"; -"623 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_1" -> "624 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1"; -"624 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" -> "626 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0"; -"625 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "626 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0"; -"626 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/conv2d_0" -> "627 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"627 DenseNet/Sequential[dense4]/Bottleneck[7]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "628 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0"; -"628 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0" -> "629 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"628 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0" -> "640 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0"; -"629 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "630 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_0"; -"630 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_0" -> "631 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0"; -"631 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" -> "633 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0"; -"632 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "633 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0"; -"633 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv1]/conv2d_0" -> "634 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"634 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "635 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_1"; -"635 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_1" -> "636 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1"; -"636 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" -> "638 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0"; -"637 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "638 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0"; -"638 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/conv2d_0" -> "639 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"639 DenseNet/Sequential[dense4]/Bottleneck[8]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "640 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0"; -"640 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0" -> "641 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"640 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0" -> "652 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0"; -"641 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "642 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_0"; -"642 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_0" -> "643 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0"; -"643 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" -> "645 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0"; -"644 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "645 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0"; -"645 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv1]/conv2d_0" -> "646 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"646 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "647 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_1"; -"647 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_1" -> "648 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1"; -"648 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" -> "650 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0"; -"649 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "650 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0"; -"650 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/conv2d_0" -> "651 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"651 DenseNet/Sequential[dense4]/Bottleneck[9]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "652 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0"; -"652 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0" -> "653 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"652 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0" -> "664 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0"; -"653 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "654 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_0"; -"654 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_0" -> "655 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0"; -"655 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" -> "657 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0"; -"656 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "657 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0"; -"657 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv1]/conv2d_0" -> "658 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"658 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "659 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_1"; -"659 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_1" -> "660 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1"; -"660 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" -> "662 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0"; -"661 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "662 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0"; -"662 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/conv2d_0" -> "663 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"663 DenseNet/Sequential[dense4]/Bottleneck[10]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "664 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0"; -"664 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0" -> "665 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"664 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0" -> "676 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0"; -"665 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "666 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_0"; -"666 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_0" -> "667 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0"; -"667 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" -> "669 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0"; -"668 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "669 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0"; -"669 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv1]/conv2d_0" -> "670 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"670 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "671 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_1"; -"671 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_1" -> "672 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1"; -"672 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" -> "674 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0"; -"673 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "674 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0"; -"674 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/conv2d_0" -> "675 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"675 DenseNet/Sequential[dense4]/Bottleneck[11]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "676 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0"; -"676 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0" -> "677 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"676 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0" -> "688 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0"; -"677 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "678 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_0"; -"678 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_0" -> "679 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0"; -"679 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" -> "681 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0"; -"680 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "681 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0"; -"681 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv1]/conv2d_0" -> "682 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"682 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "683 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_1"; -"683 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_1" -> "684 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1"; -"684 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" -> "686 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0"; -"685 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "686 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0"; -"686 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/conv2d_0" -> "687 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"687 DenseNet/Sequential[dense4]/Bottleneck[12]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "688 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0"; -"688 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0" -> "689 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"688 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0" -> "700 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0"; -"689 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "690 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_0"; -"690 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_0" -> "691 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0"; -"691 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" -> "693 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0"; -"692 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "693 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0"; -"693 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv1]/conv2d_0" -> "694 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"694 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "695 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_1"; -"695 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_1" -> "696 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1"; -"696 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" -> "698 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0"; -"697 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "698 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0"; -"698 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/conv2d_0" -> "699 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"699 DenseNet/Sequential[dense4]/Bottleneck[13]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "700 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0"; -"700 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0" -> "701 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"700 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0" -> "712 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0"; -"701 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "702 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_0"; -"702 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_0" -> "703 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0"; -"703 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" -> "705 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0"; -"704 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "705 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0"; -"705 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv1]/conv2d_0" -> "706 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"706 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "707 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_1"; -"707 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_1" -> "708 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1"; -"708 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" -> "710 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0"; -"709 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "710 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0"; -"710 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/conv2d_0" -> "711 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"711 DenseNet/Sequential[dense4]/Bottleneck[14]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "712 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0"; -"712 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0" -> "713 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"712 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0" -> "724 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0"; -"713 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "714 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_0"; -"714 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_0" -> "715 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0"; -"715 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" -> "717 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0"; -"716 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "717 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0"; -"717 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv1]/conv2d_0" -> "718 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"718 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "719 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_1"; -"719 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_1" -> "720 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1"; -"720 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" -> "722 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0"; -"721 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "722 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0"; -"722 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/conv2d_0" -> "723 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; -"723 DenseNet/Sequential[dense4]/Bottleneck[15]/NNCFConv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "724 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0"; -"724 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0" -> "725 DenseNet/NNCFBatchNorm2d[bn]/batch_norm_0"; -"725 DenseNet/NNCFBatchNorm2d[bn]/batch_norm_0" -> "726 DenseNet/relu_0"; -"726 DenseNet/relu_0" -> "727 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/relu_0|OUTPUT]/symmetric_quantize_0"; -"727 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "728 DenseNet/avg_pool2d_0"; -"728 DenseNet/avg_pool2d_0" -> "729 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; -"729 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "730 DenseNet/view_0"; -"730 DenseNet/view_0" -> "732 DenseNet/NNCFLinear[linear]/linear_0"; -"731 DenseNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "732 DenseNet/NNCFLinear[linear]/linear_0"; -"732 DenseNet/NNCFLinear[linear]/linear_0" -> "733 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "4 DenseNet/Conv2d[conv1]/conv2d_0"; +"2 conv1.weight" -> "3 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"3 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "4 DenseNet/Conv2d[conv1]/conv2d_0"; +"4 DenseNet/Conv2d[conv1]/conv2d_0" -> "5 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_1"; +"5 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_1" -> "8 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"5 DenseNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_1" -> "23 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0"; +"6 dense1.0.bn1.weight" -> "8 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"7 dense1.0.bn1.bias" -> "8 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"8 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "9 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_0"; +"9 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_0" -> "10 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"10 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "13 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"11 dense1.0.conv1.weight" -> "12 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"12 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "13 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"13 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "16 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"14 dense1.0.bn2.weight" -> "16 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"15 dense1.0.bn2.bias" -> "16 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"16 DenseNet/Sequential[dense1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "17 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_1"; +"17 DenseNet/Sequential[dense1]/Bottleneck[0]/relu_1" -> "18 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"18 DenseNet/Sequential[dense1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "21 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"19 dense1.0.conv2.weight" -> "20 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"20 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "21 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"21 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "22 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"22 DenseNet/Sequential[dense1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "23 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0"; +"23 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0" -> "26 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"23 DenseNet/Sequential[dense1]/Bottleneck[0]/cat_0" -> "41 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0"; +"24 dense1.1.bn1.weight" -> "26 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"25 dense1.1.bn1.bias" -> "26 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"26 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "27 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_0"; +"27 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_0" -> "28 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"28 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "31 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"29 dense1.1.conv1.weight" -> "30 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"30 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "31 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"31 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "34 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"32 dense1.1.bn2.weight" -> "34 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"33 dense1.1.bn2.bias" -> "34 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"34 DenseNet/Sequential[dense1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "35 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_1"; +"35 DenseNet/Sequential[dense1]/Bottleneck[1]/relu_1" -> "36 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"36 DenseNet/Sequential[dense1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "39 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"37 dense1.1.conv2.weight" -> "38 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"38 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "39 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"39 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "40 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"40 DenseNet/Sequential[dense1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "41 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0"; +"41 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0" -> "44 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"41 DenseNet/Sequential[dense1]/Bottleneck[1]/cat_0" -> "59 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0"; +"42 dense1.2.bn1.weight" -> "44 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"43 dense1.2.bn1.bias" -> "44 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"44 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "45 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_0"; +"45 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_0" -> "46 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"46 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "49 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"47 dense1.2.conv1.weight" -> "48 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"48 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "49 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"49 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "52 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"50 dense1.2.bn2.weight" -> "52 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"51 dense1.2.bn2.bias" -> "52 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"52 DenseNet/Sequential[dense1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "53 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_1"; +"53 DenseNet/Sequential[dense1]/Bottleneck[2]/relu_1" -> "54 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"54 DenseNet/Sequential[dense1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "57 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"55 dense1.2.conv2.weight" -> "56 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"56 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "57 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"57 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "58 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"58 DenseNet/Sequential[dense1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "59 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0"; +"59 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0" -> "62 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"59 DenseNet/Sequential[dense1]/Bottleneck[2]/cat_0" -> "77 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0"; +"60 dense1.3.bn1.weight" -> "62 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"61 dense1.3.bn1.bias" -> "62 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"62 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" -> "63 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_0"; +"63 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_0" -> "64 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; +"64 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "67 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"65 dense1.3.conv1.weight" -> "66 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"66 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "67 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"67 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" -> "70 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"68 dense1.3.bn2.weight" -> "70 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"69 dense1.3.bn2.bias" -> "70 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"70 DenseNet/Sequential[dense1]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" -> "71 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_1"; +"71 DenseNet/Sequential[dense1]/Bottleneck[3]/relu_1" -> "72 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; +"72 DenseNet/Sequential[dense1]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "75 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"73 dense1.3.conv2.weight" -> "74 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"74 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "75 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"75 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" -> "76 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"76 DenseNet/Sequential[dense1]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "77 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0"; +"77 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0" -> "80 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"77 DenseNet/Sequential[dense1]/Bottleneck[3]/cat_0" -> "95 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0"; +"78 dense1.4.bn1.weight" -> "80 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"79 dense1.4.bn1.bias" -> "80 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"80 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" -> "81 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_0"; +"81 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_0" -> "82 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; +"82 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "85 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"83 dense1.4.conv1.weight" -> "84 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"84 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "85 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"85 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" -> "88 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"86 dense1.4.bn2.weight" -> "88 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"87 dense1.4.bn2.bias" -> "88 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"88 DenseNet/Sequential[dense1]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" -> "89 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_1"; +"89 DenseNet/Sequential[dense1]/Bottleneck[4]/relu_1" -> "90 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; +"90 DenseNet/Sequential[dense1]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "93 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"91 dense1.4.conv2.weight" -> "92 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"92 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "93 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"93 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" -> "94 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"94 DenseNet/Sequential[dense1]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "95 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0"; +"95 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0" -> "98 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"95 DenseNet/Sequential[dense1]/Bottleneck[4]/cat_0" -> "113 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0"; +"96 dense1.5.bn1.weight" -> "98 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"97 dense1.5.bn1.bias" -> "98 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"98 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" -> "99 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_0"; +"99 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_0" -> "100 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; +"100 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "103 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"101 dense1.5.conv1.weight" -> "102 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"102 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "103 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"103 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" -> "106 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"104 dense1.5.bn2.weight" -> "106 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"105 dense1.5.bn2.bias" -> "106 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"106 DenseNet/Sequential[dense1]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" -> "107 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_1"; +"107 DenseNet/Sequential[dense1]/Bottleneck[5]/relu_1" -> "108 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; +"108 DenseNet/Sequential[dense1]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "111 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"109 dense1.5.conv2.weight" -> "110 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"110 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "111 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"111 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" -> "112 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"112 DenseNet/Sequential[dense1]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "113 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0"; +"113 DenseNet/Sequential[dense1]/Bottleneck[5]/cat_0" -> "116 DenseNet/Transition[trans1]/BatchNorm2d[bn]/batch_norm_0"; +"114 trans1.bn.weight" -> "116 DenseNet/Transition[trans1]/BatchNorm2d[bn]/batch_norm_0"; +"115 trans1.bn.bias" -> "116 DenseNet/Transition[trans1]/BatchNorm2d[bn]/batch_norm_0"; +"116 DenseNet/Transition[trans1]/BatchNorm2d[bn]/batch_norm_0" -> "117 DenseNet/Transition[trans1]/relu_0"; +"117 DenseNet/Transition[trans1]/relu_0" -> "118 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_0"; +"118 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_0" -> "121 DenseNet/Transition[trans1]/Conv2d[conv]/conv2d_0"; +"119 trans1.conv.weight" -> "120 DenseNet/Transition[trans1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"120 DenseNet/Transition[trans1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "121 DenseNet/Transition[trans1]/Conv2d[conv]/conv2d_0"; +"121 DenseNet/Transition[trans1]/Conv2d[conv]/conv2d_0" -> "122 DenseNet/Transition[trans1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"122 DenseNet/Transition[trans1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "123 DenseNet/Transition[trans1]/avg_pool2d_0"; +"123 DenseNet/Transition[trans1]/avg_pool2d_0" -> "124 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1"; +"124 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1" -> "127 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"124 DenseNet/Transition[trans1]/SymmetricQuantizer/symmetric_quantize_1" -> "142 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0"; +"125 dense2.0.bn1.weight" -> "127 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"126 dense2.0.bn1.bias" -> "127 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"127 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "128 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_0"; +"128 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_0" -> "129 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"129 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "132 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"130 dense2.0.conv1.weight" -> "131 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"131 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "132 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"132 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "135 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"133 dense2.0.bn2.weight" -> "135 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"134 dense2.0.bn2.bias" -> "135 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"135 DenseNet/Sequential[dense2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "136 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_1"; +"136 DenseNet/Sequential[dense2]/Bottleneck[0]/relu_1" -> "137 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"137 DenseNet/Sequential[dense2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "140 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"138 dense2.0.conv2.weight" -> "139 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"139 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "140 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"140 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "141 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"141 DenseNet/Sequential[dense2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "142 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0"; +"142 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0" -> "145 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"142 DenseNet/Sequential[dense2]/Bottleneck[0]/cat_0" -> "160 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0"; +"143 dense2.1.bn1.weight" -> "145 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"144 dense2.1.bn1.bias" -> "145 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"145 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "146 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_0"; +"146 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_0" -> "147 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"147 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "150 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"148 dense2.1.conv1.weight" -> "149 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"149 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "150 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"150 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "153 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"151 dense2.1.bn2.weight" -> "153 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"152 dense2.1.bn2.bias" -> "153 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"153 DenseNet/Sequential[dense2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "154 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_1"; +"154 DenseNet/Sequential[dense2]/Bottleneck[1]/relu_1" -> "155 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"155 DenseNet/Sequential[dense2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "158 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"156 dense2.1.conv2.weight" -> "157 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"157 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "158 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"158 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "159 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"159 DenseNet/Sequential[dense2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "160 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0"; +"160 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0" -> "163 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"160 DenseNet/Sequential[dense2]/Bottleneck[1]/cat_0" -> "178 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0"; +"161 dense2.2.bn1.weight" -> "163 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"162 dense2.2.bn1.bias" -> "163 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"163 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "164 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_0"; +"164 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_0" -> "165 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"165 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "168 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"166 dense2.2.conv1.weight" -> "167 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"167 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "168 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"168 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "171 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"169 dense2.2.bn2.weight" -> "171 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"170 dense2.2.bn2.bias" -> "171 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"171 DenseNet/Sequential[dense2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "172 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_1"; +"172 DenseNet/Sequential[dense2]/Bottleneck[2]/relu_1" -> "173 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"173 DenseNet/Sequential[dense2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "176 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"174 dense2.2.conv2.weight" -> "175 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"175 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "176 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"176 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "177 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"177 DenseNet/Sequential[dense2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "178 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0"; +"178 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0" -> "181 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"178 DenseNet/Sequential[dense2]/Bottleneck[2]/cat_0" -> "196 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0"; +"179 dense2.3.bn1.weight" -> "181 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"180 dense2.3.bn1.bias" -> "181 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"181 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" -> "182 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_0"; +"182 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_0" -> "183 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; +"183 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "186 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"184 dense2.3.conv1.weight" -> "185 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"185 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "186 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"186 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" -> "189 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"187 dense2.3.bn2.weight" -> "189 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"188 dense2.3.bn2.bias" -> "189 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"189 DenseNet/Sequential[dense2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" -> "190 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_1"; +"190 DenseNet/Sequential[dense2]/Bottleneck[3]/relu_1" -> "191 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; +"191 DenseNet/Sequential[dense2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "194 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"192 dense2.3.conv2.weight" -> "193 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"193 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "194 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"194 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" -> "195 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"195 DenseNet/Sequential[dense2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "196 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0"; +"196 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0" -> "199 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"196 DenseNet/Sequential[dense2]/Bottleneck[3]/cat_0" -> "214 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0"; +"197 dense2.4.bn1.weight" -> "199 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"198 dense2.4.bn1.bias" -> "199 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"199 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" -> "200 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_0"; +"200 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_0" -> "201 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; +"201 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "204 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"202 dense2.4.conv1.weight" -> "203 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"203 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "204 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"204 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" -> "207 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"205 dense2.4.bn2.weight" -> "207 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"206 dense2.4.bn2.bias" -> "207 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"207 DenseNet/Sequential[dense2]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" -> "208 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_1"; +"208 DenseNet/Sequential[dense2]/Bottleneck[4]/relu_1" -> "209 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; +"209 DenseNet/Sequential[dense2]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "212 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"210 dense2.4.conv2.weight" -> "211 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"211 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "212 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"212 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" -> "213 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"213 DenseNet/Sequential[dense2]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "214 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0"; +"214 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0" -> "217 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"214 DenseNet/Sequential[dense2]/Bottleneck[4]/cat_0" -> "232 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0"; +"215 dense2.5.bn1.weight" -> "217 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"216 dense2.5.bn1.bias" -> "217 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"217 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" -> "218 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_0"; +"218 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_0" -> "219 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; +"219 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "222 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"220 dense2.5.conv1.weight" -> "221 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"221 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "222 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"222 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" -> "225 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"223 dense2.5.bn2.weight" -> "225 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"224 dense2.5.bn2.bias" -> "225 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"225 DenseNet/Sequential[dense2]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" -> "226 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_1"; +"226 DenseNet/Sequential[dense2]/Bottleneck[5]/relu_1" -> "227 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; +"227 DenseNet/Sequential[dense2]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "230 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"228 dense2.5.conv2.weight" -> "229 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"229 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "230 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"230 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" -> "231 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"231 DenseNet/Sequential[dense2]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "232 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0"; +"232 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0" -> "235 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"232 DenseNet/Sequential[dense2]/Bottleneck[5]/cat_0" -> "250 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0"; +"233 dense2.6.bn1.weight" -> "235 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"234 dense2.6.bn1.bias" -> "235 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"235 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0" -> "236 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_0"; +"236 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_0" -> "237 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0"; +"237 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" -> "240 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/conv2d_0"; +"238 dense2.6.conv1.weight" -> "239 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"239 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "240 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/conv2d_0"; +"240 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv1]/conv2d_0" -> "243 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"241 dense2.6.bn2.weight" -> "243 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"242 dense2.6.bn2.bias" -> "243 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"243 DenseNet/Sequential[dense2]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0" -> "244 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_1"; +"244 DenseNet/Sequential[dense2]/Bottleneck[6]/relu_1" -> "245 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1"; +"245 DenseNet/Sequential[dense2]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" -> "248 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/conv2d_0"; +"246 dense2.6.conv2.weight" -> "247 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"247 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "248 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/conv2d_0"; +"248 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/conv2d_0" -> "249 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"249 DenseNet/Sequential[dense2]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "250 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0"; +"250 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0" -> "253 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"250 DenseNet/Sequential[dense2]/Bottleneck[6]/cat_0" -> "268 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0"; +"251 dense2.7.bn1.weight" -> "253 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"252 dense2.7.bn1.bias" -> "253 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"253 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0" -> "254 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_0"; +"254 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_0" -> "255 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0"; +"255 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" -> "258 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/conv2d_0"; +"256 dense2.7.conv1.weight" -> "257 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"257 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "258 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/conv2d_0"; +"258 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv1]/conv2d_0" -> "261 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"259 dense2.7.bn2.weight" -> "261 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"260 dense2.7.bn2.bias" -> "261 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"261 DenseNet/Sequential[dense2]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0" -> "262 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_1"; +"262 DenseNet/Sequential[dense2]/Bottleneck[7]/relu_1" -> "263 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1"; +"263 DenseNet/Sequential[dense2]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" -> "266 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/conv2d_0"; +"264 dense2.7.conv2.weight" -> "265 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"265 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "266 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/conv2d_0"; +"266 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/conv2d_0" -> "267 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"267 DenseNet/Sequential[dense2]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "268 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0"; +"268 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0" -> "271 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"268 DenseNet/Sequential[dense2]/Bottleneck[7]/cat_0" -> "286 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0"; +"269 dense2.8.bn1.weight" -> "271 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"270 dense2.8.bn1.bias" -> "271 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"271 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0" -> "272 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_0"; +"272 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_0" -> "273 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0"; +"273 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" -> "276 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/conv2d_0"; +"274 dense2.8.conv1.weight" -> "275 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"275 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "276 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/conv2d_0"; +"276 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv1]/conv2d_0" -> "279 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"277 dense2.8.bn2.weight" -> "279 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"278 dense2.8.bn2.bias" -> "279 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"279 DenseNet/Sequential[dense2]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0" -> "280 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_1"; +"280 DenseNet/Sequential[dense2]/Bottleneck[8]/relu_1" -> "281 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1"; +"281 DenseNet/Sequential[dense2]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" -> "284 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/conv2d_0"; +"282 dense2.8.conv2.weight" -> "283 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"283 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "284 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/conv2d_0"; +"284 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/conv2d_0" -> "285 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"285 DenseNet/Sequential[dense2]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "286 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0"; +"286 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0" -> "289 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"286 DenseNet/Sequential[dense2]/Bottleneck[8]/cat_0" -> "304 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0"; +"287 dense2.9.bn1.weight" -> "289 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"288 dense2.9.bn1.bias" -> "289 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"289 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0" -> "290 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_0"; +"290 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_0" -> "291 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0"; +"291 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" -> "294 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/conv2d_0"; +"292 dense2.9.conv1.weight" -> "293 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"293 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "294 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/conv2d_0"; +"294 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv1]/conv2d_0" -> "297 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"295 dense2.9.bn2.weight" -> "297 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"296 dense2.9.bn2.bias" -> "297 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"297 DenseNet/Sequential[dense2]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0" -> "298 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_1"; +"298 DenseNet/Sequential[dense2]/Bottleneck[9]/relu_1" -> "299 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1"; +"299 DenseNet/Sequential[dense2]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" -> "302 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/conv2d_0"; +"300 dense2.9.conv2.weight" -> "301 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"301 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "302 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/conv2d_0"; +"302 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/conv2d_0" -> "303 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"303 DenseNet/Sequential[dense2]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "304 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0"; +"304 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0" -> "307 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"304 DenseNet/Sequential[dense2]/Bottleneck[9]/cat_0" -> "322 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0"; +"305 dense2.10.bn1.weight" -> "307 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"306 dense2.10.bn1.bias" -> "307 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"307 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0" -> "308 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_0"; +"308 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_0" -> "309 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0"; +"309 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" -> "312 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/conv2d_0"; +"310 dense2.10.conv1.weight" -> "311 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"311 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "312 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/conv2d_0"; +"312 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv1]/conv2d_0" -> "315 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"313 dense2.10.bn2.weight" -> "315 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"314 dense2.10.bn2.bias" -> "315 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"315 DenseNet/Sequential[dense2]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0" -> "316 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_1"; +"316 DenseNet/Sequential[dense2]/Bottleneck[10]/relu_1" -> "317 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1"; +"317 DenseNet/Sequential[dense2]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" -> "320 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/conv2d_0"; +"318 dense2.10.conv2.weight" -> "319 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"319 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "320 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/conv2d_0"; +"320 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/conv2d_0" -> "321 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"321 DenseNet/Sequential[dense2]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "322 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0"; +"322 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0" -> "325 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"322 DenseNet/Sequential[dense2]/Bottleneck[10]/cat_0" -> "340 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0"; +"323 dense2.11.bn1.weight" -> "325 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"324 dense2.11.bn1.bias" -> "325 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"325 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0" -> "326 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_0"; +"326 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_0" -> "327 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0"; +"327 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" -> "330 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/conv2d_0"; +"328 dense2.11.conv1.weight" -> "329 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"329 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "330 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/conv2d_0"; +"330 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv1]/conv2d_0" -> "333 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"331 dense2.11.bn2.weight" -> "333 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"332 dense2.11.bn2.bias" -> "333 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"333 DenseNet/Sequential[dense2]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0" -> "334 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_1"; +"334 DenseNet/Sequential[dense2]/Bottleneck[11]/relu_1" -> "335 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1"; +"335 DenseNet/Sequential[dense2]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" -> "338 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/conv2d_0"; +"336 dense2.11.conv2.weight" -> "337 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"337 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "338 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/conv2d_0"; +"338 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/conv2d_0" -> "339 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"339 DenseNet/Sequential[dense2]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "340 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0"; +"340 DenseNet/Sequential[dense2]/Bottleneck[11]/cat_0" -> "343 DenseNet/Transition[trans2]/BatchNorm2d[bn]/batch_norm_0"; +"341 trans2.bn.weight" -> "343 DenseNet/Transition[trans2]/BatchNorm2d[bn]/batch_norm_0"; +"342 trans2.bn.bias" -> "343 DenseNet/Transition[trans2]/BatchNorm2d[bn]/batch_norm_0"; +"343 DenseNet/Transition[trans2]/BatchNorm2d[bn]/batch_norm_0" -> "344 DenseNet/Transition[trans2]/relu_0"; +"344 DenseNet/Transition[trans2]/relu_0" -> "345 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_0"; +"345 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_0" -> "348 DenseNet/Transition[trans2]/Conv2d[conv]/conv2d_0"; +"346 trans2.conv.weight" -> "347 DenseNet/Transition[trans2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"347 DenseNet/Transition[trans2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "348 DenseNet/Transition[trans2]/Conv2d[conv]/conv2d_0"; +"348 DenseNet/Transition[trans2]/Conv2d[conv]/conv2d_0" -> "349 DenseNet/Transition[trans2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"349 DenseNet/Transition[trans2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "350 DenseNet/Transition[trans2]/avg_pool2d_0"; +"350 DenseNet/Transition[trans2]/avg_pool2d_0" -> "351 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1"; +"351 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1" -> "354 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"351 DenseNet/Transition[trans2]/SymmetricQuantizer/symmetric_quantize_1" -> "369 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0"; +"352 dense3.0.bn1.weight" -> "354 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"353 dense3.0.bn1.bias" -> "354 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"354 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "355 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_0"; +"355 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_0" -> "356 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"356 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "359 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"357 dense3.0.conv1.weight" -> "358 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"358 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "359 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"359 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "362 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"360 dense3.0.bn2.weight" -> "362 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"361 dense3.0.bn2.bias" -> "362 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"362 DenseNet/Sequential[dense3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "363 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_1"; +"363 DenseNet/Sequential[dense3]/Bottleneck[0]/relu_1" -> "364 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"364 DenseNet/Sequential[dense3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "367 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"365 dense3.0.conv2.weight" -> "366 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"366 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "367 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"367 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "368 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"368 DenseNet/Sequential[dense3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "369 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0"; +"369 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0" -> "372 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"369 DenseNet/Sequential[dense3]/Bottleneck[0]/cat_0" -> "387 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0"; +"370 dense3.1.bn1.weight" -> "372 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"371 dense3.1.bn1.bias" -> "372 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"372 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "373 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_0"; +"373 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_0" -> "374 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"374 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "377 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"375 dense3.1.conv1.weight" -> "376 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"376 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "377 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"377 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "380 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"378 dense3.1.bn2.weight" -> "380 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"379 dense3.1.bn2.bias" -> "380 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"380 DenseNet/Sequential[dense3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "381 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_1"; +"381 DenseNet/Sequential[dense3]/Bottleneck[1]/relu_1" -> "382 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"382 DenseNet/Sequential[dense3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "385 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"383 dense3.1.conv2.weight" -> "384 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"384 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "385 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"385 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "386 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"386 DenseNet/Sequential[dense3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "387 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0"; +"387 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0" -> "390 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"387 DenseNet/Sequential[dense3]/Bottleneck[1]/cat_0" -> "405 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0"; +"388 dense3.2.bn1.weight" -> "390 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"389 dense3.2.bn1.bias" -> "390 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"390 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "391 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_0"; +"391 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_0" -> "392 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"392 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "395 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"393 dense3.2.conv1.weight" -> "394 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"394 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "395 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"395 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "398 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"396 dense3.2.bn2.weight" -> "398 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"397 dense3.2.bn2.bias" -> "398 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"398 DenseNet/Sequential[dense3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "399 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_1"; +"399 DenseNet/Sequential[dense3]/Bottleneck[2]/relu_1" -> "400 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"400 DenseNet/Sequential[dense3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "403 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"401 dense3.2.conv2.weight" -> "402 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"402 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "403 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"403 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "404 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"404 DenseNet/Sequential[dense3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "405 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0"; +"405 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0" -> "408 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"405 DenseNet/Sequential[dense3]/Bottleneck[2]/cat_0" -> "423 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0"; +"406 dense3.3.bn1.weight" -> "408 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"407 dense3.3.bn1.bias" -> "408 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"408 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" -> "409 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_0"; +"409 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_0" -> "410 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; +"410 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "413 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"411 dense3.3.conv1.weight" -> "412 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"412 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "413 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"413 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" -> "416 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"414 dense3.3.bn2.weight" -> "416 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"415 dense3.3.bn2.bias" -> "416 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"416 DenseNet/Sequential[dense3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" -> "417 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_1"; +"417 DenseNet/Sequential[dense3]/Bottleneck[3]/relu_1" -> "418 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; +"418 DenseNet/Sequential[dense3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "421 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"419 dense3.3.conv2.weight" -> "420 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"420 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "421 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"421 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" -> "422 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"422 DenseNet/Sequential[dense3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "423 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0"; +"423 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0" -> "426 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"423 DenseNet/Sequential[dense3]/Bottleneck[3]/cat_0" -> "441 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0"; +"424 dense3.4.bn1.weight" -> "426 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"425 dense3.4.bn1.bias" -> "426 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"426 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" -> "427 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_0"; +"427 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_0" -> "428 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; +"428 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "431 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"429 dense3.4.conv1.weight" -> "430 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"430 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "431 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"431 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" -> "434 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"432 dense3.4.bn2.weight" -> "434 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"433 dense3.4.bn2.bias" -> "434 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"434 DenseNet/Sequential[dense3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" -> "435 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_1"; +"435 DenseNet/Sequential[dense3]/Bottleneck[4]/relu_1" -> "436 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; +"436 DenseNet/Sequential[dense3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "439 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"437 dense3.4.conv2.weight" -> "438 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"438 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "439 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"439 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" -> "440 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"440 DenseNet/Sequential[dense3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "441 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0"; +"441 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0" -> "444 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"441 DenseNet/Sequential[dense3]/Bottleneck[4]/cat_0" -> "459 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0"; +"442 dense3.5.bn1.weight" -> "444 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"443 dense3.5.bn1.bias" -> "444 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"444 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" -> "445 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_0"; +"445 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_0" -> "446 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; +"446 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "449 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"447 dense3.5.conv1.weight" -> "448 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"448 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "449 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"449 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" -> "452 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"450 dense3.5.bn2.weight" -> "452 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"451 dense3.5.bn2.bias" -> "452 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"452 DenseNet/Sequential[dense3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" -> "453 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_1"; +"453 DenseNet/Sequential[dense3]/Bottleneck[5]/relu_1" -> "454 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; +"454 DenseNet/Sequential[dense3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "457 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"455 dense3.5.conv2.weight" -> "456 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"456 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "457 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"457 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" -> "458 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"458 DenseNet/Sequential[dense3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "459 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0"; +"459 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0" -> "462 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"459 DenseNet/Sequential[dense3]/Bottleneck[5]/cat_0" -> "477 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0"; +"460 dense3.6.bn1.weight" -> "462 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"461 dense3.6.bn1.bias" -> "462 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"462 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0" -> "463 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_0"; +"463 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_0" -> "464 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0"; +"464 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" -> "467 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/conv2d_0"; +"465 dense3.6.conv1.weight" -> "466 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"466 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "467 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/conv2d_0"; +"467 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv1]/conv2d_0" -> "470 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"468 dense3.6.bn2.weight" -> "470 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"469 dense3.6.bn2.bias" -> "470 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"470 DenseNet/Sequential[dense3]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0" -> "471 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_1"; +"471 DenseNet/Sequential[dense3]/Bottleneck[6]/relu_1" -> "472 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1"; +"472 DenseNet/Sequential[dense3]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" -> "475 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/conv2d_0"; +"473 dense3.6.conv2.weight" -> "474 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"474 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "475 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/conv2d_0"; +"475 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/conv2d_0" -> "476 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"476 DenseNet/Sequential[dense3]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "477 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0"; +"477 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0" -> "480 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"477 DenseNet/Sequential[dense3]/Bottleneck[6]/cat_0" -> "495 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0"; +"478 dense3.7.bn1.weight" -> "480 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"479 dense3.7.bn1.bias" -> "480 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"480 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0" -> "481 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_0"; +"481 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_0" -> "482 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0"; +"482 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" -> "485 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/conv2d_0"; +"483 dense3.7.conv1.weight" -> "484 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"484 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "485 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/conv2d_0"; +"485 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv1]/conv2d_0" -> "488 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"486 dense3.7.bn2.weight" -> "488 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"487 dense3.7.bn2.bias" -> "488 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"488 DenseNet/Sequential[dense3]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0" -> "489 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_1"; +"489 DenseNet/Sequential[dense3]/Bottleneck[7]/relu_1" -> "490 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1"; +"490 DenseNet/Sequential[dense3]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" -> "493 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/conv2d_0"; +"491 dense3.7.conv2.weight" -> "492 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"492 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "493 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/conv2d_0"; +"493 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/conv2d_0" -> "494 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"494 DenseNet/Sequential[dense3]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "495 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0"; +"495 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0" -> "498 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"495 DenseNet/Sequential[dense3]/Bottleneck[7]/cat_0" -> "513 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0"; +"496 dense3.8.bn1.weight" -> "498 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"497 dense3.8.bn1.bias" -> "498 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"498 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0" -> "499 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_0"; +"499 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_0" -> "500 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0"; +"500 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" -> "503 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/conv2d_0"; +"501 dense3.8.conv1.weight" -> "502 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"502 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "503 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/conv2d_0"; +"503 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv1]/conv2d_0" -> "506 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"504 dense3.8.bn2.weight" -> "506 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"505 dense3.8.bn2.bias" -> "506 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"506 DenseNet/Sequential[dense3]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0" -> "507 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_1"; +"507 DenseNet/Sequential[dense3]/Bottleneck[8]/relu_1" -> "508 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1"; +"508 DenseNet/Sequential[dense3]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" -> "511 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/conv2d_0"; +"509 dense3.8.conv2.weight" -> "510 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"510 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "511 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/conv2d_0"; +"511 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/conv2d_0" -> "512 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"512 DenseNet/Sequential[dense3]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "513 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0"; +"513 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0" -> "516 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"513 DenseNet/Sequential[dense3]/Bottleneck[8]/cat_0" -> "531 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0"; +"514 dense3.9.bn1.weight" -> "516 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"515 dense3.9.bn1.bias" -> "516 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"516 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0" -> "517 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_0"; +"517 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_0" -> "518 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0"; +"518 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" -> "521 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/conv2d_0"; +"519 dense3.9.conv1.weight" -> "520 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"520 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "521 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/conv2d_0"; +"521 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv1]/conv2d_0" -> "524 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"522 dense3.9.bn2.weight" -> "524 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"523 dense3.9.bn2.bias" -> "524 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"524 DenseNet/Sequential[dense3]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0" -> "525 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_1"; +"525 DenseNet/Sequential[dense3]/Bottleneck[9]/relu_1" -> "526 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1"; +"526 DenseNet/Sequential[dense3]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" -> "529 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/conv2d_0"; +"527 dense3.9.conv2.weight" -> "528 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"528 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "529 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/conv2d_0"; +"529 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/conv2d_0" -> "530 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"530 DenseNet/Sequential[dense3]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "531 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0"; +"531 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0" -> "534 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"531 DenseNet/Sequential[dense3]/Bottleneck[9]/cat_0" -> "549 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0"; +"532 dense3.10.bn1.weight" -> "534 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"533 dense3.10.bn1.bias" -> "534 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"534 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0" -> "535 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_0"; +"535 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_0" -> "536 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0"; +"536 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" -> "539 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/conv2d_0"; +"537 dense3.10.conv1.weight" -> "538 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"538 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "539 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/conv2d_0"; +"539 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv1]/conv2d_0" -> "542 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"540 dense3.10.bn2.weight" -> "542 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"541 dense3.10.bn2.bias" -> "542 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"542 DenseNet/Sequential[dense3]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0" -> "543 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_1"; +"543 DenseNet/Sequential[dense3]/Bottleneck[10]/relu_1" -> "544 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1"; +"544 DenseNet/Sequential[dense3]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" -> "547 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/conv2d_0"; +"545 dense3.10.conv2.weight" -> "546 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"546 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "547 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/conv2d_0"; +"547 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/conv2d_0" -> "548 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"548 DenseNet/Sequential[dense3]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "549 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0"; +"549 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0" -> "552 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"549 DenseNet/Sequential[dense3]/Bottleneck[10]/cat_0" -> "567 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0"; +"550 dense3.11.bn1.weight" -> "552 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"551 dense3.11.bn1.bias" -> "552 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"552 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0" -> "553 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_0"; +"553 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_0" -> "554 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0"; +"554 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" -> "557 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/conv2d_0"; +"555 dense3.11.conv1.weight" -> "556 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"556 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "557 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/conv2d_0"; +"557 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv1]/conv2d_0" -> "560 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"558 dense3.11.bn2.weight" -> "560 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"559 dense3.11.bn2.bias" -> "560 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"560 DenseNet/Sequential[dense3]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0" -> "561 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_1"; +"561 DenseNet/Sequential[dense3]/Bottleneck[11]/relu_1" -> "562 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1"; +"562 DenseNet/Sequential[dense3]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" -> "565 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/conv2d_0"; +"563 dense3.11.conv2.weight" -> "564 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"564 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "565 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/conv2d_0"; +"565 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/conv2d_0" -> "566 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"566 DenseNet/Sequential[dense3]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "567 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0"; +"567 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0" -> "570 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0"; +"567 DenseNet/Sequential[dense3]/Bottleneck[11]/cat_0" -> "585 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0"; +"568 dense3.12.bn1.weight" -> "570 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0"; +"569 dense3.12.bn1.bias" -> "570 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0"; +"570 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0" -> "571 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_0"; +"571 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_0" -> "572 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0"; +"572 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" -> "575 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/conv2d_0"; +"573 dense3.12.conv1.weight" -> "574 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"574 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "575 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/conv2d_0"; +"575 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv1]/conv2d_0" -> "578 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0"; +"576 dense3.12.bn2.weight" -> "578 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0"; +"577 dense3.12.bn2.bias" -> "578 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0"; +"578 DenseNet/Sequential[dense3]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0" -> "579 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_1"; +"579 DenseNet/Sequential[dense3]/Bottleneck[12]/relu_1" -> "580 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1"; +"580 DenseNet/Sequential[dense3]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" -> "583 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/conv2d_0"; +"581 dense3.12.conv2.weight" -> "582 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"582 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "583 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/conv2d_0"; +"583 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/conv2d_0" -> "584 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"584 DenseNet/Sequential[dense3]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "585 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0"; +"585 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0" -> "588 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0"; +"585 DenseNet/Sequential[dense3]/Bottleneck[12]/cat_0" -> "603 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0"; +"586 dense3.13.bn1.weight" -> "588 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0"; +"587 dense3.13.bn1.bias" -> "588 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0"; +"588 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0" -> "589 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_0"; +"589 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_0" -> "590 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0"; +"590 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" -> "593 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/conv2d_0"; +"591 dense3.13.conv1.weight" -> "592 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"592 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "593 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/conv2d_0"; +"593 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv1]/conv2d_0" -> "596 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0"; +"594 dense3.13.bn2.weight" -> "596 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0"; +"595 dense3.13.bn2.bias" -> "596 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0"; +"596 DenseNet/Sequential[dense3]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0" -> "597 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_1"; +"597 DenseNet/Sequential[dense3]/Bottleneck[13]/relu_1" -> "598 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1"; +"598 DenseNet/Sequential[dense3]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" -> "601 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/conv2d_0"; +"599 dense3.13.conv2.weight" -> "600 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"600 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "601 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/conv2d_0"; +"601 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/conv2d_0" -> "602 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"602 DenseNet/Sequential[dense3]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "603 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0"; +"603 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0" -> "606 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0"; +"603 DenseNet/Sequential[dense3]/Bottleneck[13]/cat_0" -> "621 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0"; +"604 dense3.14.bn1.weight" -> "606 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0"; +"605 dense3.14.bn1.bias" -> "606 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0"; +"606 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0" -> "607 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_0"; +"607 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_0" -> "608 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0"; +"608 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" -> "611 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/conv2d_0"; +"609 dense3.14.conv1.weight" -> "610 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"610 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "611 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/conv2d_0"; +"611 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv1]/conv2d_0" -> "614 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0"; +"612 dense3.14.bn2.weight" -> "614 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0"; +"613 dense3.14.bn2.bias" -> "614 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0"; +"614 DenseNet/Sequential[dense3]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0" -> "615 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_1"; +"615 DenseNet/Sequential[dense3]/Bottleneck[14]/relu_1" -> "616 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1"; +"616 DenseNet/Sequential[dense3]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" -> "619 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/conv2d_0"; +"617 dense3.14.conv2.weight" -> "618 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"618 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "619 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/conv2d_0"; +"619 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/conv2d_0" -> "620 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"620 DenseNet/Sequential[dense3]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "621 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0"; +"621 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0" -> "624 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0"; +"621 DenseNet/Sequential[dense3]/Bottleneck[14]/cat_0" -> "639 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0"; +"622 dense3.15.bn1.weight" -> "624 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0"; +"623 dense3.15.bn1.bias" -> "624 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0"; +"624 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0" -> "625 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_0"; +"625 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_0" -> "626 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0"; +"626 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" -> "629 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/conv2d_0"; +"627 dense3.15.conv1.weight" -> "628 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"628 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "629 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/conv2d_0"; +"629 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv1]/conv2d_0" -> "632 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0"; +"630 dense3.15.bn2.weight" -> "632 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0"; +"631 dense3.15.bn2.bias" -> "632 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0"; +"632 DenseNet/Sequential[dense3]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0" -> "633 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_1"; +"633 DenseNet/Sequential[dense3]/Bottleneck[15]/relu_1" -> "634 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1"; +"634 DenseNet/Sequential[dense3]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" -> "637 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/conv2d_0"; +"635 dense3.15.conv2.weight" -> "636 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"636 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "637 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/conv2d_0"; +"637 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/conv2d_0" -> "638 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"638 DenseNet/Sequential[dense3]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "639 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0"; +"639 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0" -> "642 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn1]/batch_norm_0"; +"639 DenseNet/Sequential[dense3]/Bottleneck[15]/cat_0" -> "657 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0"; +"640 dense3.16.bn1.weight" -> "642 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn1]/batch_norm_0"; +"641 dense3.16.bn1.bias" -> "642 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn1]/batch_norm_0"; +"642 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn1]/batch_norm_0" -> "643 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_0"; +"643 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_0" -> "644 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_0"; +"644 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_0" -> "647 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/conv2d_0"; +"645 dense3.16.conv1.weight" -> "646 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"646 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "647 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/conv2d_0"; +"647 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv1]/conv2d_0" -> "650 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn2]/batch_norm_0"; +"648 dense3.16.bn2.weight" -> "650 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn2]/batch_norm_0"; +"649 dense3.16.bn2.bias" -> "650 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn2]/batch_norm_0"; +"650 DenseNet/Sequential[dense3]/Bottleneck[16]/BatchNorm2d[bn2]/batch_norm_0" -> "651 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_1"; +"651 DenseNet/Sequential[dense3]/Bottleneck[16]/relu_1" -> "652 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_1"; +"652 DenseNet/Sequential[dense3]/Bottleneck[16]/SymmetricQuantizer/symmetric_quantize_1" -> "655 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/conv2d_0"; +"653 dense3.16.conv2.weight" -> "654 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"654 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "655 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/conv2d_0"; +"655 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/conv2d_0" -> "656 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"656 DenseNet/Sequential[dense3]/Bottleneck[16]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "657 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0"; +"657 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0" -> "660 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn1]/batch_norm_0"; +"657 DenseNet/Sequential[dense3]/Bottleneck[16]/cat_0" -> "675 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0"; +"658 dense3.17.bn1.weight" -> "660 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn1]/batch_norm_0"; +"659 dense3.17.bn1.bias" -> "660 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn1]/batch_norm_0"; +"660 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn1]/batch_norm_0" -> "661 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_0"; +"661 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_0" -> "662 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_0"; +"662 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_0" -> "665 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/conv2d_0"; +"663 dense3.17.conv1.weight" -> "664 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"664 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "665 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/conv2d_0"; +"665 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv1]/conv2d_0" -> "668 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn2]/batch_norm_0"; +"666 dense3.17.bn2.weight" -> "668 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn2]/batch_norm_0"; +"667 dense3.17.bn2.bias" -> "668 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn2]/batch_norm_0"; +"668 DenseNet/Sequential[dense3]/Bottleneck[17]/BatchNorm2d[bn2]/batch_norm_0" -> "669 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_1"; +"669 DenseNet/Sequential[dense3]/Bottleneck[17]/relu_1" -> "670 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_1"; +"670 DenseNet/Sequential[dense3]/Bottleneck[17]/SymmetricQuantizer/symmetric_quantize_1" -> "673 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/conv2d_0"; +"671 dense3.17.conv2.weight" -> "672 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"672 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "673 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/conv2d_0"; +"673 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/conv2d_0" -> "674 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"674 DenseNet/Sequential[dense3]/Bottleneck[17]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "675 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0"; +"675 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0" -> "678 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn1]/batch_norm_0"; +"675 DenseNet/Sequential[dense3]/Bottleneck[17]/cat_0" -> "693 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0"; +"676 dense3.18.bn1.weight" -> "678 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn1]/batch_norm_0"; +"677 dense3.18.bn1.bias" -> "678 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn1]/batch_norm_0"; +"678 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn1]/batch_norm_0" -> "679 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_0"; +"679 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_0" -> "680 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_0"; +"680 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_0" -> "683 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/conv2d_0"; +"681 dense3.18.conv1.weight" -> "682 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"682 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "683 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/conv2d_0"; +"683 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv1]/conv2d_0" -> "686 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn2]/batch_norm_0"; +"684 dense3.18.bn2.weight" -> "686 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn2]/batch_norm_0"; +"685 dense3.18.bn2.bias" -> "686 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn2]/batch_norm_0"; +"686 DenseNet/Sequential[dense3]/Bottleneck[18]/BatchNorm2d[bn2]/batch_norm_0" -> "687 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_1"; +"687 DenseNet/Sequential[dense3]/Bottleneck[18]/relu_1" -> "688 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_1"; +"688 DenseNet/Sequential[dense3]/Bottleneck[18]/SymmetricQuantizer/symmetric_quantize_1" -> "691 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/conv2d_0"; +"689 dense3.18.conv2.weight" -> "690 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"690 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "691 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/conv2d_0"; +"691 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/conv2d_0" -> "692 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"692 DenseNet/Sequential[dense3]/Bottleneck[18]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "693 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0"; +"693 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0" -> "696 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn1]/batch_norm_0"; +"693 DenseNet/Sequential[dense3]/Bottleneck[18]/cat_0" -> "711 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0"; +"694 dense3.19.bn1.weight" -> "696 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn1]/batch_norm_0"; +"695 dense3.19.bn1.bias" -> "696 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn1]/batch_norm_0"; +"696 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn1]/batch_norm_0" -> "697 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_0"; +"697 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_0" -> "698 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_0"; +"698 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_0" -> "701 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/conv2d_0"; +"699 dense3.19.conv1.weight" -> "700 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"700 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "701 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/conv2d_0"; +"701 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv1]/conv2d_0" -> "704 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn2]/batch_norm_0"; +"702 dense3.19.bn2.weight" -> "704 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn2]/batch_norm_0"; +"703 dense3.19.bn2.bias" -> "704 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn2]/batch_norm_0"; +"704 DenseNet/Sequential[dense3]/Bottleneck[19]/BatchNorm2d[bn2]/batch_norm_0" -> "705 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_1"; +"705 DenseNet/Sequential[dense3]/Bottleneck[19]/relu_1" -> "706 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_1"; +"706 DenseNet/Sequential[dense3]/Bottleneck[19]/SymmetricQuantizer/symmetric_quantize_1" -> "709 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/conv2d_0"; +"707 dense3.19.conv2.weight" -> "708 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"708 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "709 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/conv2d_0"; +"709 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/conv2d_0" -> "710 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"710 DenseNet/Sequential[dense3]/Bottleneck[19]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "711 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0"; +"711 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0" -> "714 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn1]/batch_norm_0"; +"711 DenseNet/Sequential[dense3]/Bottleneck[19]/cat_0" -> "729 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0"; +"712 dense3.20.bn1.weight" -> "714 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn1]/batch_norm_0"; +"713 dense3.20.bn1.bias" -> "714 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn1]/batch_norm_0"; +"714 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn1]/batch_norm_0" -> "715 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_0"; +"715 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_0" -> "716 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_0"; +"716 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_0" -> "719 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/conv2d_0"; +"717 dense3.20.conv1.weight" -> "718 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"718 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "719 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/conv2d_0"; +"719 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv1]/conv2d_0" -> "722 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn2]/batch_norm_0"; +"720 dense3.20.bn2.weight" -> "722 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn2]/batch_norm_0"; +"721 dense3.20.bn2.bias" -> "722 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn2]/batch_norm_0"; +"722 DenseNet/Sequential[dense3]/Bottleneck[20]/BatchNorm2d[bn2]/batch_norm_0" -> "723 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_1"; +"723 DenseNet/Sequential[dense3]/Bottleneck[20]/relu_1" -> "724 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_1"; +"724 DenseNet/Sequential[dense3]/Bottleneck[20]/SymmetricQuantizer/symmetric_quantize_1" -> "727 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/conv2d_0"; +"725 dense3.20.conv2.weight" -> "726 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"726 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "727 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/conv2d_0"; +"727 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/conv2d_0" -> "728 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"728 DenseNet/Sequential[dense3]/Bottleneck[20]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "729 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0"; +"729 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0" -> "732 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn1]/batch_norm_0"; +"729 DenseNet/Sequential[dense3]/Bottleneck[20]/cat_0" -> "747 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0"; +"730 dense3.21.bn1.weight" -> "732 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn1]/batch_norm_0"; +"731 dense3.21.bn1.bias" -> "732 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn1]/batch_norm_0"; +"732 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn1]/batch_norm_0" -> "733 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_0"; +"733 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_0" -> "734 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_0"; +"734 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_0" -> "737 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/conv2d_0"; +"735 dense3.21.conv1.weight" -> "736 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"736 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "737 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/conv2d_0"; +"737 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv1]/conv2d_0" -> "740 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn2]/batch_norm_0"; +"738 dense3.21.bn2.weight" -> "740 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn2]/batch_norm_0"; +"739 dense3.21.bn2.bias" -> "740 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn2]/batch_norm_0"; +"740 DenseNet/Sequential[dense3]/Bottleneck[21]/BatchNorm2d[bn2]/batch_norm_0" -> "741 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_1"; +"741 DenseNet/Sequential[dense3]/Bottleneck[21]/relu_1" -> "742 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_1"; +"742 DenseNet/Sequential[dense3]/Bottleneck[21]/SymmetricQuantizer/symmetric_quantize_1" -> "745 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/conv2d_0"; +"743 dense3.21.conv2.weight" -> "744 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"744 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "745 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/conv2d_0"; +"745 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/conv2d_0" -> "746 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"746 DenseNet/Sequential[dense3]/Bottleneck[21]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "747 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0"; +"747 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0" -> "750 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn1]/batch_norm_0"; +"747 DenseNet/Sequential[dense3]/Bottleneck[21]/cat_0" -> "765 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0"; +"748 dense3.22.bn1.weight" -> "750 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn1]/batch_norm_0"; +"749 dense3.22.bn1.bias" -> "750 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn1]/batch_norm_0"; +"750 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn1]/batch_norm_0" -> "751 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_0"; +"751 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_0" -> "752 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_0"; +"752 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_0" -> "755 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/conv2d_0"; +"753 dense3.22.conv1.weight" -> "754 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"754 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "755 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/conv2d_0"; +"755 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv1]/conv2d_0" -> "758 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn2]/batch_norm_0"; +"756 dense3.22.bn2.weight" -> "758 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn2]/batch_norm_0"; +"757 dense3.22.bn2.bias" -> "758 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn2]/batch_norm_0"; +"758 DenseNet/Sequential[dense3]/Bottleneck[22]/BatchNorm2d[bn2]/batch_norm_0" -> "759 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_1"; +"759 DenseNet/Sequential[dense3]/Bottleneck[22]/relu_1" -> "760 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_1"; +"760 DenseNet/Sequential[dense3]/Bottleneck[22]/SymmetricQuantizer/symmetric_quantize_1" -> "763 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/conv2d_0"; +"761 dense3.22.conv2.weight" -> "762 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"762 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "763 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/conv2d_0"; +"763 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/conv2d_0" -> "764 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"764 DenseNet/Sequential[dense3]/Bottleneck[22]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "765 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0"; +"765 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0" -> "768 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn1]/batch_norm_0"; +"765 DenseNet/Sequential[dense3]/Bottleneck[22]/cat_0" -> "783 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0"; +"766 dense3.23.bn1.weight" -> "768 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn1]/batch_norm_0"; +"767 dense3.23.bn1.bias" -> "768 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn1]/batch_norm_0"; +"768 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn1]/batch_norm_0" -> "769 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_0"; +"769 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_0" -> "770 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_0"; +"770 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_0" -> "773 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/conv2d_0"; +"771 dense3.23.conv1.weight" -> "772 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"772 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "773 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/conv2d_0"; +"773 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv1]/conv2d_0" -> "776 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn2]/batch_norm_0"; +"774 dense3.23.bn2.weight" -> "776 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn2]/batch_norm_0"; +"775 dense3.23.bn2.bias" -> "776 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn2]/batch_norm_0"; +"776 DenseNet/Sequential[dense3]/Bottleneck[23]/BatchNorm2d[bn2]/batch_norm_0" -> "777 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_1"; +"777 DenseNet/Sequential[dense3]/Bottleneck[23]/relu_1" -> "778 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_1"; +"778 DenseNet/Sequential[dense3]/Bottleneck[23]/SymmetricQuantizer/symmetric_quantize_1" -> "781 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/conv2d_0"; +"779 dense3.23.conv2.weight" -> "780 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"780 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "781 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/conv2d_0"; +"781 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/conv2d_0" -> "782 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"782 DenseNet/Sequential[dense3]/Bottleneck[23]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "783 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0"; +"783 DenseNet/Sequential[dense3]/Bottleneck[23]/cat_0" -> "786 DenseNet/Transition[trans3]/BatchNorm2d[bn]/batch_norm_0"; +"784 trans3.bn.weight" -> "786 DenseNet/Transition[trans3]/BatchNorm2d[bn]/batch_norm_0"; +"785 trans3.bn.bias" -> "786 DenseNet/Transition[trans3]/BatchNorm2d[bn]/batch_norm_0"; +"786 DenseNet/Transition[trans3]/BatchNorm2d[bn]/batch_norm_0" -> "787 DenseNet/Transition[trans3]/relu_0"; +"787 DenseNet/Transition[trans3]/relu_0" -> "788 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_0"; +"788 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_0" -> "791 DenseNet/Transition[trans3]/Conv2d[conv]/conv2d_0"; +"789 trans3.conv.weight" -> "790 DenseNet/Transition[trans3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"790 DenseNet/Transition[trans3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "791 DenseNet/Transition[trans3]/Conv2d[conv]/conv2d_0"; +"791 DenseNet/Transition[trans3]/Conv2d[conv]/conv2d_0" -> "792 DenseNet/Transition[trans3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1"; +"792 DenseNet/Transition[trans3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_1" -> "793 DenseNet/Transition[trans3]/avg_pool2d_0"; +"793 DenseNet/Transition[trans3]/avg_pool2d_0" -> "794 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1"; +"794 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1" -> "797 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"794 DenseNet/Transition[trans3]/SymmetricQuantizer/symmetric_quantize_1" -> "812 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0"; +"795 dense4.0.bn1.weight" -> "797 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"796 dense4.0.bn1.bias" -> "797 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"797 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "798 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_0"; +"798 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_0" -> "799 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"799 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "802 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"800 dense4.0.conv1.weight" -> "801 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"801 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "802 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"802 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "805 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"803 dense4.0.bn2.weight" -> "805 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"804 dense4.0.bn2.bias" -> "805 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"805 DenseNet/Sequential[dense4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "806 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_1"; +"806 DenseNet/Sequential[dense4]/Bottleneck[0]/relu_1" -> "807 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"807 DenseNet/Sequential[dense4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "810 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"808 dense4.0.conv2.weight" -> "809 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"809 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "810 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"810 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "811 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"811 DenseNet/Sequential[dense4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "812 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0"; +"812 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0" -> "815 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"812 DenseNet/Sequential[dense4]/Bottleneck[0]/cat_0" -> "830 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0"; +"813 dense4.1.bn1.weight" -> "815 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"814 dense4.1.bn1.bias" -> "815 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"815 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "816 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_0"; +"816 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_0" -> "817 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"817 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "820 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"818 dense4.1.conv1.weight" -> "819 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"819 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "820 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"820 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "823 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"821 dense4.1.bn2.weight" -> "823 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"822 dense4.1.bn2.bias" -> "823 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"823 DenseNet/Sequential[dense4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "824 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_1"; +"824 DenseNet/Sequential[dense4]/Bottleneck[1]/relu_1" -> "825 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"825 DenseNet/Sequential[dense4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "828 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"826 dense4.1.conv2.weight" -> "827 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"827 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "828 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"828 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "829 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"829 DenseNet/Sequential[dense4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "830 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0"; +"830 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0" -> "833 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"830 DenseNet/Sequential[dense4]/Bottleneck[1]/cat_0" -> "848 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0"; +"831 dense4.2.bn1.weight" -> "833 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"832 dense4.2.bn1.bias" -> "833 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"833 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "834 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_0"; +"834 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_0" -> "835 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"835 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "838 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"836 dense4.2.conv1.weight" -> "837 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"837 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "838 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"838 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "841 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"839 dense4.2.bn2.weight" -> "841 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"840 dense4.2.bn2.bias" -> "841 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"841 DenseNet/Sequential[dense4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "842 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_1"; +"842 DenseNet/Sequential[dense4]/Bottleneck[2]/relu_1" -> "843 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"843 DenseNet/Sequential[dense4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "846 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"844 dense4.2.conv2.weight" -> "845 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"845 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "846 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"846 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "847 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"847 DenseNet/Sequential[dense4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "848 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0"; +"848 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0" -> "851 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"848 DenseNet/Sequential[dense4]/Bottleneck[2]/cat_0" -> "866 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0"; +"849 dense4.3.bn1.weight" -> "851 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"850 dense4.3.bn1.bias" -> "851 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"851 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" -> "852 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_0"; +"852 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_0" -> "853 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; +"853 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "856 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"854 dense4.3.conv1.weight" -> "855 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"855 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "856 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"856 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" -> "859 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"857 dense4.3.bn2.weight" -> "859 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"858 dense4.3.bn2.bias" -> "859 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"859 DenseNet/Sequential[dense4]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" -> "860 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_1"; +"860 DenseNet/Sequential[dense4]/Bottleneck[3]/relu_1" -> "861 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; +"861 DenseNet/Sequential[dense4]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "864 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"862 dense4.3.conv2.weight" -> "863 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"863 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "864 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"864 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" -> "865 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"865 DenseNet/Sequential[dense4]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "866 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0"; +"866 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0" -> "869 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"866 DenseNet/Sequential[dense4]/Bottleneck[3]/cat_0" -> "884 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0"; +"867 dense4.4.bn1.weight" -> "869 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"868 dense4.4.bn1.bias" -> "869 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"869 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" -> "870 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_0"; +"870 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_0" -> "871 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; +"871 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "874 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"872 dense4.4.conv1.weight" -> "873 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"873 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "874 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"874 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" -> "877 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"875 dense4.4.bn2.weight" -> "877 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"876 dense4.4.bn2.bias" -> "877 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"877 DenseNet/Sequential[dense4]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" -> "878 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_1"; +"878 DenseNet/Sequential[dense4]/Bottleneck[4]/relu_1" -> "879 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; +"879 DenseNet/Sequential[dense4]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "882 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"880 dense4.4.conv2.weight" -> "881 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"881 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "882 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"882 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" -> "883 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"883 DenseNet/Sequential[dense4]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "884 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0"; +"884 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0" -> "887 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"884 DenseNet/Sequential[dense4]/Bottleneck[4]/cat_0" -> "902 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0"; +"885 dense4.5.bn1.weight" -> "887 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"886 dense4.5.bn1.bias" -> "887 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"887 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" -> "888 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_0"; +"888 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_0" -> "889 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; +"889 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "892 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"890 dense4.5.conv1.weight" -> "891 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"891 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "892 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"892 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" -> "895 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"893 dense4.5.bn2.weight" -> "895 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"894 dense4.5.bn2.bias" -> "895 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"895 DenseNet/Sequential[dense4]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" -> "896 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_1"; +"896 DenseNet/Sequential[dense4]/Bottleneck[5]/relu_1" -> "897 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; +"897 DenseNet/Sequential[dense4]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "900 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"898 dense4.5.conv2.weight" -> "899 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"899 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "900 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"900 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" -> "901 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"901 DenseNet/Sequential[dense4]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "902 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0"; +"902 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0" -> "905 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"902 DenseNet/Sequential[dense4]/Bottleneck[5]/cat_0" -> "920 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0"; +"903 dense4.6.bn1.weight" -> "905 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"904 dense4.6.bn1.bias" -> "905 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0"; +"905 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn1]/batch_norm_0" -> "906 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_0"; +"906 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_0" -> "907 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0"; +"907 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_0" -> "910 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/conv2d_0"; +"908 dense4.6.conv1.weight" -> "909 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"909 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "910 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/conv2d_0"; +"910 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv1]/conv2d_0" -> "913 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"911 dense4.6.bn2.weight" -> "913 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"912 dense4.6.bn2.bias" -> "913 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0"; +"913 DenseNet/Sequential[dense4]/Bottleneck[6]/BatchNorm2d[bn2]/batch_norm_0" -> "914 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_1"; +"914 DenseNet/Sequential[dense4]/Bottleneck[6]/relu_1" -> "915 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1"; +"915 DenseNet/Sequential[dense4]/Bottleneck[6]/SymmetricQuantizer/symmetric_quantize_1" -> "918 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/conv2d_0"; +"916 dense4.6.conv2.weight" -> "917 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"917 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "918 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/conv2d_0"; +"918 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/conv2d_0" -> "919 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"919 DenseNet/Sequential[dense4]/Bottleneck[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "920 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0"; +"920 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0" -> "923 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"920 DenseNet/Sequential[dense4]/Bottleneck[6]/cat_0" -> "938 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0"; +"921 dense4.7.bn1.weight" -> "923 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"922 dense4.7.bn1.bias" -> "923 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0"; +"923 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn1]/batch_norm_0" -> "924 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_0"; +"924 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_0" -> "925 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0"; +"925 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_0" -> "928 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/conv2d_0"; +"926 dense4.7.conv1.weight" -> "927 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"927 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "928 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/conv2d_0"; +"928 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv1]/conv2d_0" -> "931 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"929 dense4.7.bn2.weight" -> "931 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"930 dense4.7.bn2.bias" -> "931 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0"; +"931 DenseNet/Sequential[dense4]/Bottleneck[7]/BatchNorm2d[bn2]/batch_norm_0" -> "932 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_1"; +"932 DenseNet/Sequential[dense4]/Bottleneck[7]/relu_1" -> "933 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1"; +"933 DenseNet/Sequential[dense4]/Bottleneck[7]/SymmetricQuantizer/symmetric_quantize_1" -> "936 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/conv2d_0"; +"934 dense4.7.conv2.weight" -> "935 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"935 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "936 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/conv2d_0"; +"936 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/conv2d_0" -> "937 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"937 DenseNet/Sequential[dense4]/Bottleneck[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "938 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0"; +"938 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0" -> "941 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"938 DenseNet/Sequential[dense4]/Bottleneck[7]/cat_0" -> "956 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0"; +"939 dense4.8.bn1.weight" -> "941 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"940 dense4.8.bn1.bias" -> "941 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0"; +"941 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn1]/batch_norm_0" -> "942 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_0"; +"942 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_0" -> "943 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0"; +"943 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_0" -> "946 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/conv2d_0"; +"944 dense4.8.conv1.weight" -> "945 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"945 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "946 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/conv2d_0"; +"946 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv1]/conv2d_0" -> "949 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"947 dense4.8.bn2.weight" -> "949 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"948 dense4.8.bn2.bias" -> "949 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0"; +"949 DenseNet/Sequential[dense4]/Bottleneck[8]/BatchNorm2d[bn2]/batch_norm_0" -> "950 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_1"; +"950 DenseNet/Sequential[dense4]/Bottleneck[8]/relu_1" -> "951 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1"; +"951 DenseNet/Sequential[dense4]/Bottleneck[8]/SymmetricQuantizer/symmetric_quantize_1" -> "954 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/conv2d_0"; +"952 dense4.8.conv2.weight" -> "953 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"953 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "954 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/conv2d_0"; +"954 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/conv2d_0" -> "955 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"955 DenseNet/Sequential[dense4]/Bottleneck[8]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "956 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0"; +"956 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0" -> "959 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"956 DenseNet/Sequential[dense4]/Bottleneck[8]/cat_0" -> "974 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0"; +"957 dense4.9.bn1.weight" -> "959 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"958 dense4.9.bn1.bias" -> "959 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0"; +"959 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn1]/batch_norm_0" -> "960 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_0"; +"960 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_0" -> "961 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0"; +"961 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_0" -> "964 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/conv2d_0"; +"962 dense4.9.conv1.weight" -> "963 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"963 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "964 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/conv2d_0"; +"964 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv1]/conv2d_0" -> "967 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"965 dense4.9.bn2.weight" -> "967 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"966 dense4.9.bn2.bias" -> "967 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0"; +"967 DenseNet/Sequential[dense4]/Bottleneck[9]/BatchNorm2d[bn2]/batch_norm_0" -> "968 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_1"; +"968 DenseNet/Sequential[dense4]/Bottleneck[9]/relu_1" -> "969 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1"; +"969 DenseNet/Sequential[dense4]/Bottleneck[9]/SymmetricQuantizer/symmetric_quantize_1" -> "972 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/conv2d_0"; +"970 dense4.9.conv2.weight" -> "971 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"971 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "972 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/conv2d_0"; +"972 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/conv2d_0" -> "973 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"973 DenseNet/Sequential[dense4]/Bottleneck[9]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "974 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0"; +"974 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0" -> "977 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"974 DenseNet/Sequential[dense4]/Bottleneck[9]/cat_0" -> "992 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0"; +"975 dense4.10.bn1.weight" -> "977 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"976 dense4.10.bn1.bias" -> "977 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0"; +"977 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn1]/batch_norm_0" -> "978 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_0"; +"978 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_0" -> "979 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0"; +"979 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_0" -> "982 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/conv2d_0"; +"980 dense4.10.conv1.weight" -> "981 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"981 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "982 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/conv2d_0"; +"982 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv1]/conv2d_0" -> "985 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"983 dense4.10.bn2.weight" -> "985 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"984 dense4.10.bn2.bias" -> "985 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0"; +"985 DenseNet/Sequential[dense4]/Bottleneck[10]/BatchNorm2d[bn2]/batch_norm_0" -> "986 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_1"; +"986 DenseNet/Sequential[dense4]/Bottleneck[10]/relu_1" -> "987 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1"; +"987 DenseNet/Sequential[dense4]/Bottleneck[10]/SymmetricQuantizer/symmetric_quantize_1" -> "990 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/conv2d_0"; +"988 dense4.10.conv2.weight" -> "989 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"989 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "990 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/conv2d_0"; +"990 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/conv2d_0" -> "991 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"991 DenseNet/Sequential[dense4]/Bottleneck[10]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "992 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0"; +"992 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0" -> "995 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"992 DenseNet/Sequential[dense4]/Bottleneck[10]/cat_0" -> "1010 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0"; +"993 dense4.11.bn1.weight" -> "995 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"994 dense4.11.bn1.bias" -> "995 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0"; +"995 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn1]/batch_norm_0" -> "996 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_0"; +"996 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_0" -> "997 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0"; +"997 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_0" -> "1000 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/conv2d_0"; +"998 dense4.11.conv1.weight" -> "999 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"999 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "1000 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/conv2d_0"; +"1000 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv1]/conv2d_0" -> "1003 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"1001 dense4.11.bn2.weight" -> "1003 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"1002 dense4.11.bn2.bias" -> "1003 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0"; +"1003 DenseNet/Sequential[dense4]/Bottleneck[11]/BatchNorm2d[bn2]/batch_norm_0" -> "1004 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_1"; +"1004 DenseNet/Sequential[dense4]/Bottleneck[11]/relu_1" -> "1005 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1"; +"1005 DenseNet/Sequential[dense4]/Bottleneck[11]/SymmetricQuantizer/symmetric_quantize_1" -> "1008 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/conv2d_0"; +"1006 dense4.11.conv2.weight" -> "1007 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"1007 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "1008 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/conv2d_0"; +"1008 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/conv2d_0" -> "1009 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"1009 DenseNet/Sequential[dense4]/Bottleneck[11]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "1010 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0"; +"1010 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0" -> "1013 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0"; +"1010 DenseNet/Sequential[dense4]/Bottleneck[11]/cat_0" -> "1028 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0"; +"1011 dense4.12.bn1.weight" -> "1013 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0"; +"1012 dense4.12.bn1.bias" -> "1013 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0"; +"1013 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn1]/batch_norm_0" -> "1014 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_0"; +"1014 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_0" -> "1015 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0"; +"1015 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_0" -> "1018 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/conv2d_0"; +"1016 dense4.12.conv1.weight" -> "1017 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"1017 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "1018 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/conv2d_0"; +"1018 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv1]/conv2d_0" -> "1021 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0"; +"1019 dense4.12.bn2.weight" -> "1021 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0"; +"1020 dense4.12.bn2.bias" -> "1021 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0"; +"1021 DenseNet/Sequential[dense4]/Bottleneck[12]/BatchNorm2d[bn2]/batch_norm_0" -> "1022 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_1"; +"1022 DenseNet/Sequential[dense4]/Bottleneck[12]/relu_1" -> "1023 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1"; +"1023 DenseNet/Sequential[dense4]/Bottleneck[12]/SymmetricQuantizer/symmetric_quantize_1" -> "1026 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/conv2d_0"; +"1024 dense4.12.conv2.weight" -> "1025 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"1025 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "1026 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/conv2d_0"; +"1026 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/conv2d_0" -> "1027 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"1027 DenseNet/Sequential[dense4]/Bottleneck[12]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "1028 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0"; +"1028 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0" -> "1031 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0"; +"1028 DenseNet/Sequential[dense4]/Bottleneck[12]/cat_0" -> "1046 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0"; +"1029 dense4.13.bn1.weight" -> "1031 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0"; +"1030 dense4.13.bn1.bias" -> "1031 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0"; +"1031 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn1]/batch_norm_0" -> "1032 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_0"; +"1032 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_0" -> "1033 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0"; +"1033 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_0" -> "1036 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/conv2d_0"; +"1034 dense4.13.conv1.weight" -> "1035 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"1035 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "1036 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/conv2d_0"; +"1036 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv1]/conv2d_0" -> "1039 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0"; +"1037 dense4.13.bn2.weight" -> "1039 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0"; +"1038 dense4.13.bn2.bias" -> "1039 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0"; +"1039 DenseNet/Sequential[dense4]/Bottleneck[13]/BatchNorm2d[bn2]/batch_norm_0" -> "1040 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_1"; +"1040 DenseNet/Sequential[dense4]/Bottleneck[13]/relu_1" -> "1041 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1"; +"1041 DenseNet/Sequential[dense4]/Bottleneck[13]/SymmetricQuantizer/symmetric_quantize_1" -> "1044 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/conv2d_0"; +"1042 dense4.13.conv2.weight" -> "1043 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"1043 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "1044 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/conv2d_0"; +"1044 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/conv2d_0" -> "1045 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"1045 DenseNet/Sequential[dense4]/Bottleneck[13]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "1046 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0"; +"1046 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0" -> "1049 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0"; +"1046 DenseNet/Sequential[dense4]/Bottleneck[13]/cat_0" -> "1064 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0"; +"1047 dense4.14.bn1.weight" -> "1049 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0"; +"1048 dense4.14.bn1.bias" -> "1049 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0"; +"1049 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn1]/batch_norm_0" -> "1050 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_0"; +"1050 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_0" -> "1051 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0"; +"1051 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_0" -> "1054 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/conv2d_0"; +"1052 dense4.14.conv1.weight" -> "1053 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"1053 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "1054 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/conv2d_0"; +"1054 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv1]/conv2d_0" -> "1057 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0"; +"1055 dense4.14.bn2.weight" -> "1057 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0"; +"1056 dense4.14.bn2.bias" -> "1057 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0"; +"1057 DenseNet/Sequential[dense4]/Bottleneck[14]/BatchNorm2d[bn2]/batch_norm_0" -> "1058 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_1"; +"1058 DenseNet/Sequential[dense4]/Bottleneck[14]/relu_1" -> "1059 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1"; +"1059 DenseNet/Sequential[dense4]/Bottleneck[14]/SymmetricQuantizer/symmetric_quantize_1" -> "1062 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/conv2d_0"; +"1060 dense4.14.conv2.weight" -> "1061 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"1061 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "1062 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/conv2d_0"; +"1062 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/conv2d_0" -> "1063 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"1063 DenseNet/Sequential[dense4]/Bottleneck[14]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "1064 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0"; +"1064 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0" -> "1067 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0"; +"1064 DenseNet/Sequential[dense4]/Bottleneck[14]/cat_0" -> "1082 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0"; +"1065 dense4.15.bn1.weight" -> "1067 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0"; +"1066 dense4.15.bn1.bias" -> "1067 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0"; +"1067 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn1]/batch_norm_0" -> "1068 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_0"; +"1068 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_0" -> "1069 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0"; +"1069 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_0" -> "1072 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/conv2d_0"; +"1070 dense4.15.conv1.weight" -> "1071 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"1071 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "1072 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/conv2d_0"; +"1072 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv1]/conv2d_0" -> "1075 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0"; +"1073 dense4.15.bn2.weight" -> "1075 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0"; +"1074 dense4.15.bn2.bias" -> "1075 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0"; +"1075 DenseNet/Sequential[dense4]/Bottleneck[15]/BatchNorm2d[bn2]/batch_norm_0" -> "1076 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_1"; +"1076 DenseNet/Sequential[dense4]/Bottleneck[15]/relu_1" -> "1077 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1"; +"1077 DenseNet/Sequential[dense4]/Bottleneck[15]/SymmetricQuantizer/symmetric_quantize_1" -> "1080 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/conv2d_0"; +"1078 dense4.15.conv2.weight" -> "1079 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"1079 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "1080 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/conv2d_0"; +"1080 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/conv2d_0" -> "1081 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1"; +"1081 DenseNet/Sequential[dense4]/Bottleneck[15]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_1" -> "1082 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0"; +"1082 DenseNet/Sequential[dense4]/Bottleneck[15]/cat_0" -> "1085 DenseNet/BatchNorm2d[bn]/batch_norm_0"; +"1083 bn.weight" -> "1085 DenseNet/BatchNorm2d[bn]/batch_norm_0"; +"1084 bn.bias" -> "1085 DenseNet/BatchNorm2d[bn]/batch_norm_0"; +"1085 DenseNet/BatchNorm2d[bn]/batch_norm_0" -> "1086 DenseNet/relu_0"; +"1086 DenseNet/relu_0" -> "1087 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/relu_0|OUTPUT]/symmetric_quantize_0"; +"1087 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "1088 DenseNet/avg_pool2d_0"; +"1088 DenseNet/avg_pool2d_0" -> "1089 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; +"1089 DenseNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[DenseNet/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "1090 DenseNet/view_0"; +"1090 DenseNet/view_0" -> "1094 DenseNet/Linear[linear]/linear_0"; +"1091 linear.weight" -> "1093 DenseNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0"; +"1092 linear.bias" -> "1094 DenseNet/Linear[linear]/linear_0"; +"1093 DenseNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" -> "1094 DenseNet/Linear[linear]/linear_0"; +"1094 DenseNet/Linear[linear]/linear_0" -> "1095 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/embedding_model.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/embedding_model.dot index 1e471670ca5..5ba2cf2ef63 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/embedding_model.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/embedding_model.dot @@ -1,15 +1,21 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 EmbeddingModel/type_0" [id=1, type=type]; -"2 EmbeddingModel/NNCFEmbedding[embedding]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 EmbeddingModel/NNCFEmbedding[embedding]/embedding_0" [id=3, type=embedding]; -"4 EmbeddingModel/NNCFLinear[matmul]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=4, type=symmetric_quantize]; -"5 EmbeddingModel/NNCFLinear[matmul]/linear_0" [id=5, type=linear]; -"6 /nncf_model_output_0" [id=6, type=nncf_model_output]; +"2 embedding.weight" [id=2, type=nncf_model_const]; +"3 EmbeddingModel/Embedding[embedding]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 EmbeddingModel/Embedding[embedding]/embedding_0" [id=4, type=embedding]; +"5 matmul.weight" [id=5, type=nncf_model_const]; +"6 matmul.bias" [id=6, type=nncf_model_const]; +"7 EmbeddingModel/Linear[matmul]/SymmetricQuantizer/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 EmbeddingModel/Linear[matmul]/linear_0" [id=8, type=linear]; +"9 /nncf_model_output_0" [id=9, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 EmbeddingModel/type_0"; -"1 EmbeddingModel/type_0" -> "3 EmbeddingModel/NNCFEmbedding[embedding]/embedding_0"; -"2 EmbeddingModel/NNCFEmbedding[embedding]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 EmbeddingModel/NNCFEmbedding[embedding]/embedding_0"; -"3 EmbeddingModel/NNCFEmbedding[embedding]/embedding_0" -> "5 EmbeddingModel/NNCFLinear[matmul]/linear_0"; -"4 EmbeddingModel/NNCFLinear[matmul]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "5 EmbeddingModel/NNCFLinear[matmul]/linear_0"; -"5 EmbeddingModel/NNCFLinear[matmul]/linear_0" -> "6 /nncf_model_output_0"; +"1 EmbeddingModel/type_0" -> "4 EmbeddingModel/Embedding[embedding]/embedding_0"; +"2 embedding.weight" -> "3 EmbeddingModel/Embedding[embedding]/SymmetricQuantizer/symmetric_quantize_0"; +"3 EmbeddingModel/Embedding[embedding]/SymmetricQuantizer/symmetric_quantize_0" -> "4 EmbeddingModel/Embedding[embedding]/embedding_0"; +"4 EmbeddingModel/Embedding[embedding]/embedding_0" -> "8 EmbeddingModel/Linear[matmul]/linear_0"; +"5 matmul.weight" -> "7 EmbeddingModel/Linear[matmul]/SymmetricQuantizer/symmetric_quantize_0"; +"6 matmul.bias" -> "8 EmbeddingModel/Linear[matmul]/linear_0"; +"7 EmbeddingModel/Linear[matmul]/SymmetricQuantizer/symmetric_quantize_0" -> "8 EmbeddingModel/Linear[matmul]/linear_0"; +"8 EmbeddingModel/Linear[matmul]/linear_0" -> "9 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception.dot index 43cce9c40cd..8d044066ace 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception.dot @@ -1,724 +1,1240 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 GoogLeNet/Sequential[pre_layers]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 GoogLeNet/Sequential[pre_layers]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 GoogLeNet/Sequential[pre_layers]/NNCFBatchNorm2d[1]/batch_norm_0" [id=4, type=batch_norm]; -"5 GoogLeNet/Sequential[pre_layers]/ReLU[2]/relu__0" [id=5, type=relu_]; -"6 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=8, type=conv2d]; -"9 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=9, type=batch_norm]; -"10 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/relu__0" [id=10, type=relu_]; -"11 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=12, type=symmetric_quantize]; -"13 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=13, type=conv2d]; -"14 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=14, type=batch_norm]; -"15 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/relu__0" [id=15, type=relu_]; -"16 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=17, type=symmetric_quantize]; -"18 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=18, type=conv2d]; -"19 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=19, type=batch_norm]; -"20 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/relu__0" [id=20, type=relu_]; -"21 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=22, type=symmetric_quantize]; -"23 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=23, type=conv2d]; -"24 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=24, type=batch_norm]; -"25 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/relu__0" [id=25, type=relu_]; -"26 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=26, type=symmetric_quantize]; -"27 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=27, type=symmetric_quantize]; -"28 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=28, type=conv2d]; -"29 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=29, type=batch_norm]; -"30 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/relu__0" [id=30, type=relu_]; -"31 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; -"32 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=32, type=symmetric_quantize]; -"33 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=33, type=conv2d]; -"34 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=34, type=batch_norm]; -"35 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/relu__0" [id=35, type=relu_]; -"36 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; -"37 GoogLeNet/Inception[a3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=37, type=max_pool2d]; -"38 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=38, type=symmetric_quantize]; -"39 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=39, type=conv2d]; -"40 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=40, type=batch_norm]; -"41 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/relu__0" [id=41, type=relu_]; -"42 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; -"43 GoogLeNet/Inception[a3]/cat_0" [id=43, type=cat]; -"44 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=45, type=conv2d]; -"46 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=46, type=batch_norm]; -"47 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/relu__0" [id=47, type=relu_]; -"48 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; -"49 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=49, type=symmetric_quantize]; -"50 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=50, type=conv2d]; -"51 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=51, type=batch_norm]; -"52 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/relu__0" [id=52, type=relu_]; -"53 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=53, type=symmetric_quantize]; -"54 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=54, type=symmetric_quantize]; -"55 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=55, type=conv2d]; -"56 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=56, type=batch_norm]; -"57 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/relu__0" [id=57, type=relu_]; -"58 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=58, type=symmetric_quantize]; -"59 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=59, type=symmetric_quantize]; -"60 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=60, type=conv2d]; -"61 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=61, type=batch_norm]; -"62 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/relu__0" [id=62, type=relu_]; -"63 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; -"64 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=65, type=conv2d]; -"66 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=66, type=batch_norm]; -"67 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/relu__0" [id=67, type=relu_]; -"68 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; -"69 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=70, type=conv2d]; -"71 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=71, type=batch_norm]; -"72 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/relu__0" [id=72, type=relu_]; -"73 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 GoogLeNet/Inception[b3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=74, type=max_pool2d]; -"75 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=76, type=conv2d]; -"77 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=77, type=batch_norm]; -"78 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/relu__0" [id=78, type=relu_]; -"79 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; -"80 GoogLeNet/Inception[b3]/cat_0" [id=80, type=cat]; -"81 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" [id=81, type=max_pool2d]; -"82 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=82, type=symmetric_quantize]; -"83 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=83, type=conv2d]; -"84 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=84, type=batch_norm]; -"85 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/relu__0" [id=85, type=relu_]; -"86 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=86, type=symmetric_quantize]; -"87 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=87, type=symmetric_quantize]; -"88 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=88, type=conv2d]; -"89 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=89, type=batch_norm]; -"90 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/relu__0" [id=90, type=relu_]; -"91 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=92, type=symmetric_quantize]; -"93 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=93, type=conv2d]; -"94 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=94, type=batch_norm]; -"95 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/relu__0" [id=95, type=relu_]; -"96 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=97, type=symmetric_quantize]; -"98 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=98, type=conv2d]; -"99 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=99, type=batch_norm]; -"100 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/relu__0" [id=100, type=relu_]; -"101 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; -"102 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=102, type=symmetric_quantize]; -"103 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=103, type=conv2d]; -"104 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=104, type=batch_norm]; -"105 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/relu__0" [id=105, type=relu_]; -"106 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=106, type=symmetric_quantize]; -"107 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=107, type=symmetric_quantize]; -"108 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=108, type=conv2d]; -"109 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=109, type=batch_norm]; -"110 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/relu__0" [id=110, type=relu_]; -"111 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 GoogLeNet/Inception[a4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=112, type=max_pool2d]; -"113 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=113, type=symmetric_quantize]; -"114 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=114, type=conv2d]; -"115 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=115, type=batch_norm]; -"116 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/relu__0" [id=116, type=relu_]; -"117 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 GoogLeNet/Inception[a4]/cat_0" [id=118, type=cat]; -"119 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=119, type=symmetric_quantize]; -"120 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=120, type=conv2d]; -"121 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=121, type=batch_norm]; -"122 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/relu__0" [id=122, type=relu_]; -"123 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; -"124 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=124, type=symmetric_quantize]; -"125 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=125, type=conv2d]; -"126 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=126, type=batch_norm]; -"127 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/relu__0" [id=127, type=relu_]; -"128 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=128, type=symmetric_quantize]; -"129 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=129, type=symmetric_quantize]; -"130 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=130, type=conv2d]; -"131 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=131, type=batch_norm]; -"132 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/relu__0" [id=132, type=relu_]; -"133 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=133, type=symmetric_quantize]; -"134 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=134, type=symmetric_quantize]; -"135 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=135, type=conv2d]; -"136 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=136, type=batch_norm]; -"137 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/relu__0" [id=137, type=relu_]; -"138 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=138, type=symmetric_quantize]; -"139 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=139, type=symmetric_quantize]; -"140 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=140, type=conv2d]; -"141 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=141, type=batch_norm]; -"142 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/relu__0" [id=142, type=relu_]; -"143 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=143, type=symmetric_quantize]; -"144 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=144, type=symmetric_quantize]; -"145 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=145, type=conv2d]; -"146 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=146, type=batch_norm]; -"147 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/relu__0" [id=147, type=relu_]; -"148 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 GoogLeNet/Inception[b4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=149, type=max_pool2d]; -"150 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=150, type=symmetric_quantize]; -"151 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=151, type=conv2d]; -"152 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=152, type=batch_norm]; -"153 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/relu__0" [id=153, type=relu_]; -"154 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=154, type=symmetric_quantize]; -"155 GoogLeNet/Inception[b4]/cat_0" [id=155, type=cat]; -"156 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=156, type=symmetric_quantize]; -"157 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=157, type=conv2d]; -"158 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=158, type=batch_norm]; -"159 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/relu__0" [id=159, type=relu_]; -"160 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=160, type=symmetric_quantize]; -"161 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=161, type=symmetric_quantize]; -"162 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=162, type=conv2d]; -"163 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=163, type=batch_norm]; -"164 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/relu__0" [id=164, type=relu_]; -"165 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=165, type=symmetric_quantize]; -"166 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=166, type=symmetric_quantize]; -"167 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=167, type=conv2d]; -"168 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=168, type=batch_norm]; -"169 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/relu__0" [id=169, type=relu_]; -"170 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=170, type=symmetric_quantize]; -"171 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=171, type=symmetric_quantize]; -"172 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=172, type=conv2d]; -"173 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=173, type=batch_norm]; -"174 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/relu__0" [id=174, type=relu_]; -"175 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=175, type=symmetric_quantize]; -"176 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=176, type=symmetric_quantize]; -"177 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=177, type=conv2d]; -"178 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=178, type=batch_norm]; -"179 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/relu__0" [id=179, type=relu_]; -"180 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=180, type=symmetric_quantize]; -"181 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=181, type=symmetric_quantize]; -"182 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=182, type=conv2d]; -"183 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=183, type=batch_norm]; -"184 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/relu__0" [id=184, type=relu_]; -"185 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=185, type=symmetric_quantize]; -"186 GoogLeNet/Inception[c4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=186, type=max_pool2d]; -"187 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=187, type=symmetric_quantize]; -"188 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=188, type=conv2d]; -"189 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=189, type=batch_norm]; -"190 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/relu__0" [id=190, type=relu_]; -"191 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=191, type=symmetric_quantize]; -"192 GoogLeNet/Inception[c4]/cat_0" [id=192, type=cat]; -"193 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=193, type=symmetric_quantize]; -"194 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=194, type=conv2d]; -"195 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=195, type=batch_norm]; -"196 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/relu__0" [id=196, type=relu_]; -"197 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=197, type=symmetric_quantize]; -"198 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=198, type=symmetric_quantize]; -"199 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=199, type=conv2d]; -"200 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=200, type=batch_norm]; -"201 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/relu__0" [id=201, type=relu_]; -"202 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=202, type=symmetric_quantize]; -"203 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=203, type=symmetric_quantize]; -"204 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=204, type=conv2d]; -"205 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=205, type=batch_norm]; -"206 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/relu__0" [id=206, type=relu_]; -"207 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; -"208 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=208, type=symmetric_quantize]; -"209 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=209, type=conv2d]; -"210 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=210, type=batch_norm]; -"211 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/relu__0" [id=211, type=relu_]; -"212 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=212, type=symmetric_quantize]; -"213 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=213, type=symmetric_quantize]; -"214 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=214, type=conv2d]; -"215 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=215, type=batch_norm]; -"216 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/relu__0" [id=216, type=relu_]; -"217 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=217, type=symmetric_quantize]; -"218 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=218, type=symmetric_quantize]; -"219 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=219, type=conv2d]; -"220 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=220, type=batch_norm]; -"221 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/relu__0" [id=221, type=relu_]; -"222 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=222, type=symmetric_quantize]; -"223 GoogLeNet/Inception[d4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=223, type=max_pool2d]; -"224 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; -"225 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=225, type=conv2d]; -"226 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=226, type=batch_norm]; -"227 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/relu__0" [id=227, type=relu_]; -"228 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; -"229 GoogLeNet/Inception[d4]/cat_0" [id=229, type=cat]; -"230 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=230, type=symmetric_quantize]; -"231 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=231, type=conv2d]; -"232 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=232, type=batch_norm]; -"233 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/relu__0" [id=233, type=relu_]; -"234 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; -"235 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=235, type=symmetric_quantize]; -"236 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=236, type=conv2d]; -"237 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=237, type=batch_norm]; -"238 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/relu__0" [id=238, type=relu_]; -"239 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; -"240 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=240, type=symmetric_quantize]; -"241 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=241, type=conv2d]; -"242 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=242, type=batch_norm]; -"243 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/relu__0" [id=243, type=relu_]; -"244 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; -"245 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=245, type=symmetric_quantize]; -"246 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=246, type=conv2d]; -"247 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=247, type=batch_norm]; -"248 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/relu__0" [id=248, type=relu_]; -"249 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=249, type=symmetric_quantize]; -"250 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=250, type=symmetric_quantize]; -"251 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=251, type=conv2d]; -"252 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=252, type=batch_norm]; -"253 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/relu__0" [id=253, type=relu_]; -"254 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=254, type=symmetric_quantize]; -"255 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=255, type=symmetric_quantize]; -"256 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=256, type=conv2d]; -"257 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=257, type=batch_norm]; -"258 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/relu__0" [id=258, type=relu_]; -"259 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=259, type=symmetric_quantize]; -"260 GoogLeNet/Inception[e4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=260, type=max_pool2d]; -"261 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=261, type=symmetric_quantize]; -"262 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=262, type=conv2d]; -"263 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=263, type=batch_norm]; -"264 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/relu__0" [id=264, type=relu_]; -"265 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=265, type=symmetric_quantize]; -"266 GoogLeNet/Inception[e4]/cat_0" [id=266, type=cat]; -"267 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" [id=267, type=max_pool2d]; -"268 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=268, type=symmetric_quantize]; -"269 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=269, type=conv2d]; -"270 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=270, type=batch_norm]; -"271 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/relu__0" [id=271, type=relu_]; -"272 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=272, type=symmetric_quantize]; -"273 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=273, type=symmetric_quantize]; -"274 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=274, type=conv2d]; -"275 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=275, type=batch_norm]; -"276 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/relu__0" [id=276, type=relu_]; -"277 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=277, type=symmetric_quantize]; -"278 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=278, type=symmetric_quantize]; -"279 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=279, type=conv2d]; -"280 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=280, type=batch_norm]; -"281 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/relu__0" [id=281, type=relu_]; -"282 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=282, type=symmetric_quantize]; -"283 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=283, type=symmetric_quantize]; -"284 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=284, type=conv2d]; -"285 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=285, type=batch_norm]; -"286 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/relu__0" [id=286, type=relu_]; -"287 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=287, type=symmetric_quantize]; -"288 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=288, type=symmetric_quantize]; -"289 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=289, type=conv2d]; -"290 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=290, type=batch_norm]; -"291 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/relu__0" [id=291, type=relu_]; -"292 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=292, type=symmetric_quantize]; -"293 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=293, type=symmetric_quantize]; -"294 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=294, type=conv2d]; -"295 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=295, type=batch_norm]; -"296 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/relu__0" [id=296, type=relu_]; -"297 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=297, type=symmetric_quantize]; -"298 GoogLeNet/Inception[a5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=298, type=max_pool2d]; -"299 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=299, type=symmetric_quantize]; -"300 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=300, type=conv2d]; -"301 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=301, type=batch_norm]; -"302 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/relu__0" [id=302, type=relu_]; -"303 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=303, type=symmetric_quantize]; -"304 GoogLeNet/Inception[a5]/cat_0" [id=304, type=cat]; -"305 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=305, type=symmetric_quantize]; -"306 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" [id=306, type=conv2d]; -"307 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=307, type=batch_norm]; -"308 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/relu__0" [id=308, type=relu_]; -"309 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=309, type=symmetric_quantize]; -"310 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=310, type=symmetric_quantize]; -"311 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" [id=311, type=conv2d]; -"312 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=312, type=batch_norm]; -"313 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/relu__0" [id=313, type=relu_]; -"314 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=314, type=symmetric_quantize]; -"315 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=315, type=symmetric_quantize]; -"316 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" [id=316, type=conv2d]; -"317 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=317, type=batch_norm]; -"318 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/relu__0" [id=318, type=relu_]; -"319 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=319, type=symmetric_quantize]; -"320 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=320, type=symmetric_quantize]; -"321 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" [id=321, type=conv2d]; -"322 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=322, type=batch_norm]; -"323 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/relu__0" [id=323, type=relu_]; -"324 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=324, type=symmetric_quantize]; -"325 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=325, type=symmetric_quantize]; -"326 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" [id=326, type=conv2d]; -"327 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=327, type=batch_norm]; -"328 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/relu__0" [id=328, type=relu_]; -"329 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; -"330 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=330, type=symmetric_quantize]; -"331 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" [id=331, type=conv2d]; -"332 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" [id=332, type=batch_norm]; -"333 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/relu__0" [id=333, type=relu_]; -"334 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=334, type=symmetric_quantize]; -"335 GoogLeNet/Inception[b5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=335, type=max_pool2d]; -"336 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=336, type=symmetric_quantize]; -"337 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" [id=337, type=conv2d]; -"338 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" [id=338, type=batch_norm]; -"339 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/relu__0" [id=339, type=relu_]; -"340 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=340, type=symmetric_quantize]; -"341 GoogLeNet/Inception[b5]/cat_0" [id=341, type=cat]; -"342 GoogLeNet/AvgPool2d[avgpool]/avg_pool2d_0" [id=342, type=avg_pool2d]; -"343 GoogLeNet/AvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=343, type=symmetric_quantize]; -"344 GoogLeNet/view_0" [id=344, type=view]; -"345 GoogLeNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=345, type=symmetric_quantize]; -"346 GoogLeNet/NNCFLinear[linear]/linear_0" [id=346, type=linear]; -"347 /nncf_model_output_0" [id=347, type=nncf_model_output]; +"2 pre_layers.0.weight" [id=2, type=nncf_model_const]; +"3 pre_layers.0.bias" [id=3, type=nncf_model_const]; +"4 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/conv2d_0" [id=5, type=conv2d]; +"6 pre_layers.1.weight" [id=6, type=nncf_model_const]; +"7 pre_layers.1.bias" [id=7, type=nncf_model_const]; +"8 GoogLeNet/Sequential[pre_layers]/BatchNorm2d[1]/batch_norm_0" [id=8, type=batch_norm]; +"9 GoogLeNet/Sequential[pre_layers]/ReLU[2]/relu__0" [id=9, type=relu_]; +"10 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; +"11 a3.b1.0.weight" [id=11, type=nncf_model_const]; +"12 a3.b1.0.bias" [id=12, type=nncf_model_const]; +"13 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=14, type=conv2d]; +"15 a3.b1.1.weight" [id=15, type=nncf_model_const]; +"16 a3.b1.1.bias" [id=16, type=nncf_model_const]; +"17 GoogLeNet/Inception[a3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=17, type=batch_norm]; +"18 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/relu__0" [id=18, type=relu_]; +"19 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; +"20 a3.b2.0.weight" [id=20, type=nncf_model_const]; +"21 a3.b2.0.bias" [id=21, type=nncf_model_const]; +"22 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=23, type=conv2d]; +"24 a3.b2.1.weight" [id=24, type=nncf_model_const]; +"25 a3.b2.1.bias" [id=25, type=nncf_model_const]; +"26 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=26, type=batch_norm]; +"27 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/relu__0" [id=27, type=relu_]; +"28 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; +"29 a3.b2.3.weight" [id=29, type=nncf_model_const]; +"30 a3.b2.3.bias" [id=30, type=nncf_model_const]; +"31 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; +"32 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=32, type=conv2d]; +"33 a3.b2.4.weight" [id=33, type=nncf_model_const]; +"34 a3.b2.4.bias" [id=34, type=nncf_model_const]; +"35 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=35, type=batch_norm]; +"36 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/relu__0" [id=36, type=relu_]; +"37 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=37, type=symmetric_quantize]; +"38 a3.b3.0.weight" [id=38, type=nncf_model_const]; +"39 a3.b3.0.bias" [id=39, type=nncf_model_const]; +"40 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=40, type=symmetric_quantize]; +"41 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=41, type=conv2d]; +"42 a3.b3.1.weight" [id=42, type=nncf_model_const]; +"43 a3.b3.1.bias" [id=43, type=nncf_model_const]; +"44 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=44, type=batch_norm]; +"45 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/relu__0" [id=45, type=relu_]; +"46 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 a3.b3.3.weight" [id=47, type=nncf_model_const]; +"48 a3.b3.3.bias" [id=48, type=nncf_model_const]; +"49 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=49, type=symmetric_quantize]; +"50 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=50, type=conv2d]; +"51 a3.b3.4.weight" [id=51, type=nncf_model_const]; +"52 a3.b3.4.bias" [id=52, type=nncf_model_const]; +"53 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=53, type=batch_norm]; +"54 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/relu__0" [id=54, type=relu_]; +"55 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; +"56 a3.b3.6.weight" [id=56, type=nncf_model_const]; +"57 a3.b3.6.bias" [id=57, type=nncf_model_const]; +"58 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=58, type=symmetric_quantize]; +"59 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=59, type=conv2d]; +"60 a3.b3.7.weight" [id=60, type=nncf_model_const]; +"61 a3.b3.7.bias" [id=61, type=nncf_model_const]; +"62 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=62, type=batch_norm]; +"63 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/relu__0" [id=63, type=relu_]; +"64 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; +"65 GoogLeNet/Inception[a3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=65, type=max_pool2d]; +"66 a3.b4.1.weight" [id=66, type=nncf_model_const]; +"67 a3.b4.1.bias" [id=67, type=nncf_model_const]; +"68 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; +"69 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=69, type=conv2d]; +"70 a3.b4.2.weight" [id=70, type=nncf_model_const]; +"71 a3.b4.2.bias" [id=71, type=nncf_model_const]; +"72 GoogLeNet/Inception[a3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=72, type=batch_norm]; +"73 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/relu__0" [id=73, type=relu_]; +"74 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; +"75 GoogLeNet/Inception[a3]/cat_0" [id=75, type=cat]; +"76 b3.b1.0.weight" [id=76, type=nncf_model_const]; +"77 b3.b1.0.bias" [id=77, type=nncf_model_const]; +"78 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=78, type=symmetric_quantize]; +"79 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=79, type=conv2d]; +"80 b3.b1.1.weight" [id=80, type=nncf_model_const]; +"81 b3.b1.1.bias" [id=81, type=nncf_model_const]; +"82 GoogLeNet/Inception[b3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=82, type=batch_norm]; +"83 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/relu__0" [id=83, type=relu_]; +"84 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 b3.b2.0.weight" [id=85, type=nncf_model_const]; +"86 b3.b2.0.bias" [id=86, type=nncf_model_const]; +"87 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=87, type=symmetric_quantize]; +"88 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=88, type=conv2d]; +"89 b3.b2.1.weight" [id=89, type=nncf_model_const]; +"90 b3.b2.1.bias" [id=90, type=nncf_model_const]; +"91 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=91, type=batch_norm]; +"92 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/relu__0" [id=92, type=relu_]; +"93 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=93, type=symmetric_quantize]; +"94 b3.b2.3.weight" [id=94, type=nncf_model_const]; +"95 b3.b2.3.bias" [id=95, type=nncf_model_const]; +"96 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; +"97 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=97, type=conv2d]; +"98 b3.b2.4.weight" [id=98, type=nncf_model_const]; +"99 b3.b2.4.bias" [id=99, type=nncf_model_const]; +"100 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=100, type=batch_norm]; +"101 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/relu__0" [id=101, type=relu_]; +"102 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 b3.b3.0.weight" [id=103, type=nncf_model_const]; +"104 b3.b3.0.bias" [id=104, type=nncf_model_const]; +"105 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; +"106 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=106, type=conv2d]; +"107 b3.b3.1.weight" [id=107, type=nncf_model_const]; +"108 b3.b3.1.bias" [id=108, type=nncf_model_const]; +"109 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=109, type=batch_norm]; +"110 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/relu__0" [id=110, type=relu_]; +"111 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 b3.b3.3.weight" [id=112, type=nncf_model_const]; +"113 b3.b3.3.bias" [id=113, type=nncf_model_const]; +"114 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=115, type=conv2d]; +"116 b3.b3.4.weight" [id=116, type=nncf_model_const]; +"117 b3.b3.4.bias" [id=117, type=nncf_model_const]; +"118 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=118, type=batch_norm]; +"119 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/relu__0" [id=119, type=relu_]; +"120 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 b3.b3.6.weight" [id=121, type=nncf_model_const]; +"122 b3.b3.6.bias" [id=122, type=nncf_model_const]; +"123 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=124, type=conv2d]; +"125 b3.b3.7.weight" [id=125, type=nncf_model_const]; +"126 b3.b3.7.bias" [id=126, type=nncf_model_const]; +"127 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=127, type=batch_norm]; +"128 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/relu__0" [id=128, type=relu_]; +"129 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 GoogLeNet/Inception[b3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=130, type=max_pool2d]; +"131 b3.b4.1.weight" [id=131, type=nncf_model_const]; +"132 b3.b4.1.bias" [id=132, type=nncf_model_const]; +"133 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=133, type=symmetric_quantize]; +"134 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=134, type=conv2d]; +"135 b3.b4.2.weight" [id=135, type=nncf_model_const]; +"136 b3.b4.2.bias" [id=136, type=nncf_model_const]; +"137 GoogLeNet/Inception[b3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=137, type=batch_norm]; +"138 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/relu__0" [id=138, type=relu_]; +"139 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 GoogLeNet/Inception[b3]/cat_0" [id=140, type=cat]; +"141 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" [id=141, type=max_pool2d]; +"142 a4.b1.0.weight" [id=142, type=nncf_model_const]; +"143 a4.b1.0.bias" [id=143, type=nncf_model_const]; +"144 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=144, type=symmetric_quantize]; +"145 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=145, type=conv2d]; +"146 a4.b1.1.weight" [id=146, type=nncf_model_const]; +"147 a4.b1.1.bias" [id=147, type=nncf_model_const]; +"148 GoogLeNet/Inception[a4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=148, type=batch_norm]; +"149 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/relu__0" [id=149, type=relu_]; +"150 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=150, type=symmetric_quantize]; +"151 a4.b2.0.weight" [id=151, type=nncf_model_const]; +"152 a4.b2.0.bias" [id=152, type=nncf_model_const]; +"153 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=153, type=symmetric_quantize]; +"154 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=154, type=conv2d]; +"155 a4.b2.1.weight" [id=155, type=nncf_model_const]; +"156 a4.b2.1.bias" [id=156, type=nncf_model_const]; +"157 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=157, type=batch_norm]; +"158 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/relu__0" [id=158, type=relu_]; +"159 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=159, type=symmetric_quantize]; +"160 a4.b2.3.weight" [id=160, type=nncf_model_const]; +"161 a4.b2.3.bias" [id=161, type=nncf_model_const]; +"162 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=162, type=symmetric_quantize]; +"163 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=163, type=conv2d]; +"164 a4.b2.4.weight" [id=164, type=nncf_model_const]; +"165 a4.b2.4.bias" [id=165, type=nncf_model_const]; +"166 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=166, type=batch_norm]; +"167 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/relu__0" [id=167, type=relu_]; +"168 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=168, type=symmetric_quantize]; +"169 a4.b3.0.weight" [id=169, type=nncf_model_const]; +"170 a4.b3.0.bias" [id=170, type=nncf_model_const]; +"171 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=171, type=symmetric_quantize]; +"172 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=172, type=conv2d]; +"173 a4.b3.1.weight" [id=173, type=nncf_model_const]; +"174 a4.b3.1.bias" [id=174, type=nncf_model_const]; +"175 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=175, type=batch_norm]; +"176 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/relu__0" [id=176, type=relu_]; +"177 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; +"178 a4.b3.3.weight" [id=178, type=nncf_model_const]; +"179 a4.b3.3.bias" [id=179, type=nncf_model_const]; +"180 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=180, type=symmetric_quantize]; +"181 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=181, type=conv2d]; +"182 a4.b3.4.weight" [id=182, type=nncf_model_const]; +"183 a4.b3.4.bias" [id=183, type=nncf_model_const]; +"184 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=184, type=batch_norm]; +"185 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/relu__0" [id=185, type=relu_]; +"186 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 a4.b3.6.weight" [id=187, type=nncf_model_const]; +"188 a4.b3.6.bias" [id=188, type=nncf_model_const]; +"189 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=189, type=symmetric_quantize]; +"190 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=190, type=conv2d]; +"191 a4.b3.7.weight" [id=191, type=nncf_model_const]; +"192 a4.b3.7.bias" [id=192, type=nncf_model_const]; +"193 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=193, type=batch_norm]; +"194 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/relu__0" [id=194, type=relu_]; +"195 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 GoogLeNet/Inception[a4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=196, type=max_pool2d]; +"197 a4.b4.1.weight" [id=197, type=nncf_model_const]; +"198 a4.b4.1.bias" [id=198, type=nncf_model_const]; +"199 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=199, type=symmetric_quantize]; +"200 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=200, type=conv2d]; +"201 a4.b4.2.weight" [id=201, type=nncf_model_const]; +"202 a4.b4.2.bias" [id=202, type=nncf_model_const]; +"203 GoogLeNet/Inception[a4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=203, type=batch_norm]; +"204 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/relu__0" [id=204, type=relu_]; +"205 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=205, type=symmetric_quantize]; +"206 GoogLeNet/Inception[a4]/cat_0" [id=206, type=cat]; +"207 b4.b1.0.weight" [id=207, type=nncf_model_const]; +"208 b4.b1.0.bias" [id=208, type=nncf_model_const]; +"209 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; +"210 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=210, type=conv2d]; +"211 b4.b1.1.weight" [id=211, type=nncf_model_const]; +"212 b4.b1.1.bias" [id=212, type=nncf_model_const]; +"213 GoogLeNet/Inception[b4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=213, type=batch_norm]; +"214 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/relu__0" [id=214, type=relu_]; +"215 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=215, type=symmetric_quantize]; +"216 b4.b2.0.weight" [id=216, type=nncf_model_const]; +"217 b4.b2.0.bias" [id=217, type=nncf_model_const]; +"218 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=218, type=symmetric_quantize]; +"219 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=219, type=conv2d]; +"220 b4.b2.1.weight" [id=220, type=nncf_model_const]; +"221 b4.b2.1.bias" [id=221, type=nncf_model_const]; +"222 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=222, type=batch_norm]; +"223 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/relu__0" [id=223, type=relu_]; +"224 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=224, type=symmetric_quantize]; +"225 b4.b2.3.weight" [id=225, type=nncf_model_const]; +"226 b4.b2.3.bias" [id=226, type=nncf_model_const]; +"227 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=227, type=symmetric_quantize]; +"228 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=228, type=conv2d]; +"229 b4.b2.4.weight" [id=229, type=nncf_model_const]; +"230 b4.b2.4.bias" [id=230, type=nncf_model_const]; +"231 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=231, type=batch_norm]; +"232 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/relu__0" [id=232, type=relu_]; +"233 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=233, type=symmetric_quantize]; +"234 b4.b3.0.weight" [id=234, type=nncf_model_const]; +"235 b4.b3.0.bias" [id=235, type=nncf_model_const]; +"236 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=236, type=symmetric_quantize]; +"237 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=237, type=conv2d]; +"238 b4.b3.1.weight" [id=238, type=nncf_model_const]; +"239 b4.b3.1.bias" [id=239, type=nncf_model_const]; +"240 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=240, type=batch_norm]; +"241 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/relu__0" [id=241, type=relu_]; +"242 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=242, type=symmetric_quantize]; +"243 b4.b3.3.weight" [id=243, type=nncf_model_const]; +"244 b4.b3.3.bias" [id=244, type=nncf_model_const]; +"245 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=245, type=symmetric_quantize]; +"246 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=246, type=conv2d]; +"247 b4.b3.4.weight" [id=247, type=nncf_model_const]; +"248 b4.b3.4.bias" [id=248, type=nncf_model_const]; +"249 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=249, type=batch_norm]; +"250 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/relu__0" [id=250, type=relu_]; +"251 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 b4.b3.6.weight" [id=252, type=nncf_model_const]; +"253 b4.b3.6.bias" [id=253, type=nncf_model_const]; +"254 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=254, type=symmetric_quantize]; +"255 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=255, type=conv2d]; +"256 b4.b3.7.weight" [id=256, type=nncf_model_const]; +"257 b4.b3.7.bias" [id=257, type=nncf_model_const]; +"258 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=258, type=batch_norm]; +"259 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/relu__0" [id=259, type=relu_]; +"260 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=260, type=symmetric_quantize]; +"261 GoogLeNet/Inception[b4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=261, type=max_pool2d]; +"262 b4.b4.1.weight" [id=262, type=nncf_model_const]; +"263 b4.b4.1.bias" [id=263, type=nncf_model_const]; +"264 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=264, type=symmetric_quantize]; +"265 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=265, type=conv2d]; +"266 b4.b4.2.weight" [id=266, type=nncf_model_const]; +"267 b4.b4.2.bias" [id=267, type=nncf_model_const]; +"268 GoogLeNet/Inception[b4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=268, type=batch_norm]; +"269 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/relu__0" [id=269, type=relu_]; +"270 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=270, type=symmetric_quantize]; +"271 GoogLeNet/Inception[b4]/cat_0" [id=271, type=cat]; +"272 c4.b1.0.weight" [id=272, type=nncf_model_const]; +"273 c4.b1.0.bias" [id=273, type=nncf_model_const]; +"274 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=274, type=symmetric_quantize]; +"275 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=275, type=conv2d]; +"276 c4.b1.1.weight" [id=276, type=nncf_model_const]; +"277 c4.b1.1.bias" [id=277, type=nncf_model_const]; +"278 GoogLeNet/Inception[c4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=278, type=batch_norm]; +"279 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/relu__0" [id=279, type=relu_]; +"280 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=280, type=symmetric_quantize]; +"281 c4.b2.0.weight" [id=281, type=nncf_model_const]; +"282 c4.b2.0.bias" [id=282, type=nncf_model_const]; +"283 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=284, type=conv2d]; +"285 c4.b2.1.weight" [id=285, type=nncf_model_const]; +"286 c4.b2.1.bias" [id=286, type=nncf_model_const]; +"287 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=287, type=batch_norm]; +"288 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/relu__0" [id=288, type=relu_]; +"289 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 c4.b2.3.weight" [id=290, type=nncf_model_const]; +"291 c4.b2.3.bias" [id=291, type=nncf_model_const]; +"292 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=292, type=symmetric_quantize]; +"293 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=293, type=conv2d]; +"294 c4.b2.4.weight" [id=294, type=nncf_model_const]; +"295 c4.b2.4.bias" [id=295, type=nncf_model_const]; +"296 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=296, type=batch_norm]; +"297 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/relu__0" [id=297, type=relu_]; +"298 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=298, type=symmetric_quantize]; +"299 c4.b3.0.weight" [id=299, type=nncf_model_const]; +"300 c4.b3.0.bias" [id=300, type=nncf_model_const]; +"301 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=301, type=symmetric_quantize]; +"302 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=302, type=conv2d]; +"303 c4.b3.1.weight" [id=303, type=nncf_model_const]; +"304 c4.b3.1.bias" [id=304, type=nncf_model_const]; +"305 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=305, type=batch_norm]; +"306 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/relu__0" [id=306, type=relu_]; +"307 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=307, type=symmetric_quantize]; +"308 c4.b3.3.weight" [id=308, type=nncf_model_const]; +"309 c4.b3.3.bias" [id=309, type=nncf_model_const]; +"310 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=310, type=symmetric_quantize]; +"311 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=311, type=conv2d]; +"312 c4.b3.4.weight" [id=312, type=nncf_model_const]; +"313 c4.b3.4.bias" [id=313, type=nncf_model_const]; +"314 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=314, type=batch_norm]; +"315 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/relu__0" [id=315, type=relu_]; +"316 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=316, type=symmetric_quantize]; +"317 c4.b3.6.weight" [id=317, type=nncf_model_const]; +"318 c4.b3.6.bias" [id=318, type=nncf_model_const]; +"319 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=319, type=symmetric_quantize]; +"320 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=320, type=conv2d]; +"321 c4.b3.7.weight" [id=321, type=nncf_model_const]; +"322 c4.b3.7.bias" [id=322, type=nncf_model_const]; +"323 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=323, type=batch_norm]; +"324 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/relu__0" [id=324, type=relu_]; +"325 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=325, type=symmetric_quantize]; +"326 GoogLeNet/Inception[c4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=326, type=max_pool2d]; +"327 c4.b4.1.weight" [id=327, type=nncf_model_const]; +"328 c4.b4.1.bias" [id=328, type=nncf_model_const]; +"329 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; +"330 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=330, type=conv2d]; +"331 c4.b4.2.weight" [id=331, type=nncf_model_const]; +"332 c4.b4.2.bias" [id=332, type=nncf_model_const]; +"333 GoogLeNet/Inception[c4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=333, type=batch_norm]; +"334 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/relu__0" [id=334, type=relu_]; +"335 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 GoogLeNet/Inception[c4]/cat_0" [id=336, type=cat]; +"337 d4.b1.0.weight" [id=337, type=nncf_model_const]; +"338 d4.b1.0.bias" [id=338, type=nncf_model_const]; +"339 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=340, type=conv2d]; +"341 d4.b1.1.weight" [id=341, type=nncf_model_const]; +"342 d4.b1.1.bias" [id=342, type=nncf_model_const]; +"343 GoogLeNet/Inception[d4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=343, type=batch_norm]; +"344 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/relu__0" [id=344, type=relu_]; +"345 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=345, type=symmetric_quantize]; +"346 d4.b2.0.weight" [id=346, type=nncf_model_const]; +"347 d4.b2.0.bias" [id=347, type=nncf_model_const]; +"348 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=348, type=symmetric_quantize]; +"349 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=349, type=conv2d]; +"350 d4.b2.1.weight" [id=350, type=nncf_model_const]; +"351 d4.b2.1.bias" [id=351, type=nncf_model_const]; +"352 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=352, type=batch_norm]; +"353 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/relu__0" [id=353, type=relu_]; +"354 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=354, type=symmetric_quantize]; +"355 d4.b2.3.weight" [id=355, type=nncf_model_const]; +"356 d4.b2.3.bias" [id=356, type=nncf_model_const]; +"357 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=357, type=symmetric_quantize]; +"358 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=358, type=conv2d]; +"359 d4.b2.4.weight" [id=359, type=nncf_model_const]; +"360 d4.b2.4.bias" [id=360, type=nncf_model_const]; +"361 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=361, type=batch_norm]; +"362 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/relu__0" [id=362, type=relu_]; +"363 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=363, type=symmetric_quantize]; +"364 d4.b3.0.weight" [id=364, type=nncf_model_const]; +"365 d4.b3.0.bias" [id=365, type=nncf_model_const]; +"366 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=366, type=symmetric_quantize]; +"367 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=367, type=conv2d]; +"368 d4.b3.1.weight" [id=368, type=nncf_model_const]; +"369 d4.b3.1.bias" [id=369, type=nncf_model_const]; +"370 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=370, type=batch_norm]; +"371 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/relu__0" [id=371, type=relu_]; +"372 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=372, type=symmetric_quantize]; +"373 d4.b3.3.weight" [id=373, type=nncf_model_const]; +"374 d4.b3.3.bias" [id=374, type=nncf_model_const]; +"375 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=375, type=symmetric_quantize]; +"376 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=376, type=conv2d]; +"377 d4.b3.4.weight" [id=377, type=nncf_model_const]; +"378 d4.b3.4.bias" [id=378, type=nncf_model_const]; +"379 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=379, type=batch_norm]; +"380 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/relu__0" [id=380, type=relu_]; +"381 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=381, type=symmetric_quantize]; +"382 d4.b3.6.weight" [id=382, type=nncf_model_const]; +"383 d4.b3.6.bias" [id=383, type=nncf_model_const]; +"384 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=384, type=symmetric_quantize]; +"385 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=385, type=conv2d]; +"386 d4.b3.7.weight" [id=386, type=nncf_model_const]; +"387 d4.b3.7.bias" [id=387, type=nncf_model_const]; +"388 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=388, type=batch_norm]; +"389 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/relu__0" [id=389, type=relu_]; +"390 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=390, type=symmetric_quantize]; +"391 GoogLeNet/Inception[d4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=391, type=max_pool2d]; +"392 d4.b4.1.weight" [id=392, type=nncf_model_const]; +"393 d4.b4.1.bias" [id=393, type=nncf_model_const]; +"394 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=394, type=symmetric_quantize]; +"395 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=395, type=conv2d]; +"396 d4.b4.2.weight" [id=396, type=nncf_model_const]; +"397 d4.b4.2.bias" [id=397, type=nncf_model_const]; +"398 GoogLeNet/Inception[d4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=398, type=batch_norm]; +"399 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/relu__0" [id=399, type=relu_]; +"400 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=400, type=symmetric_quantize]; +"401 GoogLeNet/Inception[d4]/cat_0" [id=401, type=cat]; +"402 e4.b1.0.weight" [id=402, type=nncf_model_const]; +"403 e4.b1.0.bias" [id=403, type=nncf_model_const]; +"404 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=404, type=symmetric_quantize]; +"405 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=405, type=conv2d]; +"406 e4.b1.1.weight" [id=406, type=nncf_model_const]; +"407 e4.b1.1.bias" [id=407, type=nncf_model_const]; +"408 GoogLeNet/Inception[e4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=408, type=batch_norm]; +"409 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/relu__0" [id=409, type=relu_]; +"410 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=410, type=symmetric_quantize]; +"411 e4.b2.0.weight" [id=411, type=nncf_model_const]; +"412 e4.b2.0.bias" [id=412, type=nncf_model_const]; +"413 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=413, type=symmetric_quantize]; +"414 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=414, type=conv2d]; +"415 e4.b2.1.weight" [id=415, type=nncf_model_const]; +"416 e4.b2.1.bias" [id=416, type=nncf_model_const]; +"417 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=417, type=batch_norm]; +"418 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/relu__0" [id=418, type=relu_]; +"419 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=419, type=symmetric_quantize]; +"420 e4.b2.3.weight" [id=420, type=nncf_model_const]; +"421 e4.b2.3.bias" [id=421, type=nncf_model_const]; +"422 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=422, type=symmetric_quantize]; +"423 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=423, type=conv2d]; +"424 e4.b2.4.weight" [id=424, type=nncf_model_const]; +"425 e4.b2.4.bias" [id=425, type=nncf_model_const]; +"426 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=426, type=batch_norm]; +"427 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/relu__0" [id=427, type=relu_]; +"428 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=428, type=symmetric_quantize]; +"429 e4.b3.0.weight" [id=429, type=nncf_model_const]; +"430 e4.b3.0.bias" [id=430, type=nncf_model_const]; +"431 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=431, type=symmetric_quantize]; +"432 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=432, type=conv2d]; +"433 e4.b3.1.weight" [id=433, type=nncf_model_const]; +"434 e4.b3.1.bias" [id=434, type=nncf_model_const]; +"435 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=435, type=batch_norm]; +"436 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/relu__0" [id=436, type=relu_]; +"437 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=437, type=symmetric_quantize]; +"438 e4.b3.3.weight" [id=438, type=nncf_model_const]; +"439 e4.b3.3.bias" [id=439, type=nncf_model_const]; +"440 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=440, type=symmetric_quantize]; +"441 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=441, type=conv2d]; +"442 e4.b3.4.weight" [id=442, type=nncf_model_const]; +"443 e4.b3.4.bias" [id=443, type=nncf_model_const]; +"444 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=444, type=batch_norm]; +"445 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/relu__0" [id=445, type=relu_]; +"446 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=446, type=symmetric_quantize]; +"447 e4.b3.6.weight" [id=447, type=nncf_model_const]; +"448 e4.b3.6.bias" [id=448, type=nncf_model_const]; +"449 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=449, type=symmetric_quantize]; +"450 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=450, type=conv2d]; +"451 e4.b3.7.weight" [id=451, type=nncf_model_const]; +"452 e4.b3.7.bias" [id=452, type=nncf_model_const]; +"453 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=453, type=batch_norm]; +"454 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/relu__0" [id=454, type=relu_]; +"455 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=455, type=symmetric_quantize]; +"456 GoogLeNet/Inception[e4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=456, type=max_pool2d]; +"457 e4.b4.1.weight" [id=457, type=nncf_model_const]; +"458 e4.b4.1.bias" [id=458, type=nncf_model_const]; +"459 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=459, type=symmetric_quantize]; +"460 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=460, type=conv2d]; +"461 e4.b4.2.weight" [id=461, type=nncf_model_const]; +"462 e4.b4.2.bias" [id=462, type=nncf_model_const]; +"463 GoogLeNet/Inception[e4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=463, type=batch_norm]; +"464 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/relu__0" [id=464, type=relu_]; +"465 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=465, type=symmetric_quantize]; +"466 GoogLeNet/Inception[e4]/cat_0" [id=466, type=cat]; +"467 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" [id=467, type=max_pool2d]; +"468 a5.b1.0.weight" [id=468, type=nncf_model_const]; +"469 a5.b1.0.bias" [id=469, type=nncf_model_const]; +"470 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=470, type=symmetric_quantize]; +"471 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=471, type=conv2d]; +"472 a5.b1.1.weight" [id=472, type=nncf_model_const]; +"473 a5.b1.1.bias" [id=473, type=nncf_model_const]; +"474 GoogLeNet/Inception[a5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=474, type=batch_norm]; +"475 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/relu__0" [id=475, type=relu_]; +"476 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=476, type=symmetric_quantize]; +"477 a5.b2.0.weight" [id=477, type=nncf_model_const]; +"478 a5.b2.0.bias" [id=478, type=nncf_model_const]; +"479 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=479, type=symmetric_quantize]; +"480 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=480, type=conv2d]; +"481 a5.b2.1.weight" [id=481, type=nncf_model_const]; +"482 a5.b2.1.bias" [id=482, type=nncf_model_const]; +"483 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=483, type=batch_norm]; +"484 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/relu__0" [id=484, type=relu_]; +"485 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=485, type=symmetric_quantize]; +"486 a5.b2.3.weight" [id=486, type=nncf_model_const]; +"487 a5.b2.3.bias" [id=487, type=nncf_model_const]; +"488 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=488, type=symmetric_quantize]; +"489 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=489, type=conv2d]; +"490 a5.b2.4.weight" [id=490, type=nncf_model_const]; +"491 a5.b2.4.bias" [id=491, type=nncf_model_const]; +"492 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=492, type=batch_norm]; +"493 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/relu__0" [id=493, type=relu_]; +"494 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=494, type=symmetric_quantize]; +"495 a5.b3.0.weight" [id=495, type=nncf_model_const]; +"496 a5.b3.0.bias" [id=496, type=nncf_model_const]; +"497 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=497, type=symmetric_quantize]; +"498 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=498, type=conv2d]; +"499 a5.b3.1.weight" [id=499, type=nncf_model_const]; +"500 a5.b3.1.bias" [id=500, type=nncf_model_const]; +"501 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=501, type=batch_norm]; +"502 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/relu__0" [id=502, type=relu_]; +"503 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=503, type=symmetric_quantize]; +"504 a5.b3.3.weight" [id=504, type=nncf_model_const]; +"505 a5.b3.3.bias" [id=505, type=nncf_model_const]; +"506 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=506, type=symmetric_quantize]; +"507 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=507, type=conv2d]; +"508 a5.b3.4.weight" [id=508, type=nncf_model_const]; +"509 a5.b3.4.bias" [id=509, type=nncf_model_const]; +"510 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=510, type=batch_norm]; +"511 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/relu__0" [id=511, type=relu_]; +"512 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=512, type=symmetric_quantize]; +"513 a5.b3.6.weight" [id=513, type=nncf_model_const]; +"514 a5.b3.6.bias" [id=514, type=nncf_model_const]; +"515 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=515, type=symmetric_quantize]; +"516 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=516, type=conv2d]; +"517 a5.b3.7.weight" [id=517, type=nncf_model_const]; +"518 a5.b3.7.bias" [id=518, type=nncf_model_const]; +"519 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=519, type=batch_norm]; +"520 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/relu__0" [id=520, type=relu_]; +"521 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=521, type=symmetric_quantize]; +"522 GoogLeNet/Inception[a5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=522, type=max_pool2d]; +"523 a5.b4.1.weight" [id=523, type=nncf_model_const]; +"524 a5.b4.1.bias" [id=524, type=nncf_model_const]; +"525 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=525, type=symmetric_quantize]; +"526 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=526, type=conv2d]; +"527 a5.b4.2.weight" [id=527, type=nncf_model_const]; +"528 a5.b4.2.bias" [id=528, type=nncf_model_const]; +"529 GoogLeNet/Inception[a5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=529, type=batch_norm]; +"530 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/relu__0" [id=530, type=relu_]; +"531 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=531, type=symmetric_quantize]; +"532 GoogLeNet/Inception[a5]/cat_0" [id=532, type=cat]; +"533 b5.b1.0.weight" [id=533, type=nncf_model_const]; +"534 b5.b1.0.bias" [id=534, type=nncf_model_const]; +"535 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=535, type=symmetric_quantize]; +"536 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/conv2d_0" [id=536, type=conv2d]; +"537 b5.b1.1.weight" [id=537, type=nncf_model_const]; +"538 b5.b1.1.bias" [id=538, type=nncf_model_const]; +"539 GoogLeNet/Inception[b5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" [id=539, type=batch_norm]; +"540 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/relu__0" [id=540, type=relu_]; +"541 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=541, type=symmetric_quantize]; +"542 b5.b2.0.weight" [id=542, type=nncf_model_const]; +"543 b5.b2.0.bias" [id=543, type=nncf_model_const]; +"544 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=544, type=symmetric_quantize]; +"545 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/conv2d_0" [id=545, type=conv2d]; +"546 b5.b2.1.weight" [id=546, type=nncf_model_const]; +"547 b5.b2.1.bias" [id=547, type=nncf_model_const]; +"548 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" [id=548, type=batch_norm]; +"549 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/relu__0" [id=549, type=relu_]; +"550 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=550, type=symmetric_quantize]; +"551 b5.b2.3.weight" [id=551, type=nncf_model_const]; +"552 b5.b2.3.bias" [id=552, type=nncf_model_const]; +"553 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=553, type=symmetric_quantize]; +"554 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/conv2d_0" [id=554, type=conv2d]; +"555 b5.b2.4.weight" [id=555, type=nncf_model_const]; +"556 b5.b2.4.bias" [id=556, type=nncf_model_const]; +"557 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" [id=557, type=batch_norm]; +"558 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/relu__0" [id=558, type=relu_]; +"559 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=559, type=symmetric_quantize]; +"560 b5.b3.0.weight" [id=560, type=nncf_model_const]; +"561 b5.b3.0.bias" [id=561, type=nncf_model_const]; +"562 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=562, type=symmetric_quantize]; +"563 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/conv2d_0" [id=563, type=conv2d]; +"564 b5.b3.1.weight" [id=564, type=nncf_model_const]; +"565 b5.b3.1.bias" [id=565, type=nncf_model_const]; +"566 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" [id=566, type=batch_norm]; +"567 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/relu__0" [id=567, type=relu_]; +"568 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=568, type=symmetric_quantize]; +"569 b5.b3.3.weight" [id=569, type=nncf_model_const]; +"570 b5.b3.3.bias" [id=570, type=nncf_model_const]; +"571 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=571, type=symmetric_quantize]; +"572 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/conv2d_0" [id=572, type=conv2d]; +"573 b5.b3.4.weight" [id=573, type=nncf_model_const]; +"574 b5.b3.4.bias" [id=574, type=nncf_model_const]; +"575 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" [id=575, type=batch_norm]; +"576 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/relu__0" [id=576, type=relu_]; +"577 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=577, type=symmetric_quantize]; +"578 b5.b3.6.weight" [id=578, type=nncf_model_const]; +"579 b5.b3.6.bias" [id=579, type=nncf_model_const]; +"580 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=580, type=symmetric_quantize]; +"581 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/conv2d_0" [id=581, type=conv2d]; +"582 b5.b3.7.weight" [id=582, type=nncf_model_const]; +"583 b5.b3.7.bias" [id=583, type=nncf_model_const]; +"584 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" [id=584, type=batch_norm]; +"585 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/relu__0" [id=585, type=relu_]; +"586 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=586, type=symmetric_quantize]; +"587 GoogLeNet/Inception[b5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" [id=587, type=max_pool2d]; +"588 b5.b4.1.weight" [id=588, type=nncf_model_const]; +"589 b5.b4.1.bias" [id=589, type=nncf_model_const]; +"590 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=590, type=symmetric_quantize]; +"591 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/conv2d_0" [id=591, type=conv2d]; +"592 b5.b4.2.weight" [id=592, type=nncf_model_const]; +"593 b5.b4.2.bias" [id=593, type=nncf_model_const]; +"594 GoogLeNet/Inception[b5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" [id=594, type=batch_norm]; +"595 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/relu__0" [id=595, type=relu_]; +"596 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" [id=596, type=symmetric_quantize]; +"597 GoogLeNet/Inception[b5]/cat_0" [id=597, type=cat]; +"598 GoogLeNet/AvgPool2d[avgpool]/avg_pool2d_0" [id=598, type=avg_pool2d]; +"599 GoogLeNet/AvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=599, type=symmetric_quantize]; +"600 GoogLeNet/view_0" [id=600, type=view]; +"601 linear.weight" [id=601, type=nncf_model_const]; +"602 linear.bias" [id=602, type=nncf_model_const]; +"603 GoogLeNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" [id=603, type=symmetric_quantize]; +"604 GoogLeNet/Linear[linear]/linear_0" [id=604, type=linear]; +"605 /nncf_model_output_0" [id=605, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 GoogLeNet/Sequential[pre_layers]/NNCFConv2d[0]/conv2d_0"; -"2 GoogLeNet/Sequential[pre_layers]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 GoogLeNet/Sequential[pre_layers]/NNCFConv2d[0]/conv2d_0"; -"3 GoogLeNet/Sequential[pre_layers]/NNCFConv2d[0]/conv2d_0" -> "4 GoogLeNet/Sequential[pre_layers]/NNCFBatchNorm2d[1]/batch_norm_0"; -"4 GoogLeNet/Sequential[pre_layers]/NNCFBatchNorm2d[1]/batch_norm_0" -> "5 GoogLeNet/Sequential[pre_layers]/ReLU[2]/relu__0"; -"5 GoogLeNet/Sequential[pre_layers]/ReLU[2]/relu__0" -> "6 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"6 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "8 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"6 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "13 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"6 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "23 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"6 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "37 GoogLeNet/Inception[a3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"7 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"8 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "9 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"9 GoogLeNet/Inception[a3]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "10 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/relu__0"; -"10 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/relu__0" -> "11 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"11 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "43 GoogLeNet/Inception[a3]/cat_0"; -"12 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "13 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"13 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "14 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"14 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "15 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/relu__0"; -"15 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/relu__0" -> "16 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"16 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "18 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"17 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "18 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"18 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "19 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"19 GoogLeNet/Inception[a3]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "20 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/relu__0"; -"20 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/relu__0" -> "21 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"21 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "43 GoogLeNet/Inception[a3]/cat_0"; -"22 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "23 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"23 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "24 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"24 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "25 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/relu__0"; -"25 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/relu__0" -> "26 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"26 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "28 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"27 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "28 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"28 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "29 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"29 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "30 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/relu__0"; -"30 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/relu__0" -> "31 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"31 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "33 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"32 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "33 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"33 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "34 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"34 GoogLeNet/Inception[a3]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "35 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/relu__0"; -"35 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/relu__0" -> "36 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"36 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "43 GoogLeNet/Inception[a3]/cat_0"; -"37 GoogLeNet/Inception[a3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "39 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"38 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "39 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"39 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "40 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"40 GoogLeNet/Inception[a3]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "41 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/relu__0"; -"41 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/relu__0" -> "42 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"42 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "43 GoogLeNet/Inception[a3]/cat_0"; -"43 GoogLeNet/Inception[a3]/cat_0" -> "45 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"43 GoogLeNet/Inception[a3]/cat_0" -> "50 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"43 GoogLeNet/Inception[a3]/cat_0" -> "60 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"43 GoogLeNet/Inception[a3]/cat_0" -> "74 GoogLeNet/Inception[b3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"44 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "45 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"45 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "46 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"46 GoogLeNet/Inception[b3]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "47 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/relu__0"; -"47 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/relu__0" -> "48 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"48 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "80 GoogLeNet/Inception[b3]/cat_0"; -"49 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "50 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"50 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "51 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"51 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "52 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/relu__0"; -"52 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/relu__0" -> "53 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"53 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "55 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"54 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "55 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"55 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "56 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"56 GoogLeNet/Inception[b3]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "57 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/relu__0"; -"57 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/relu__0" -> "58 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"58 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "80 GoogLeNet/Inception[b3]/cat_0"; -"59 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "60 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"60 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "61 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"61 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "62 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/relu__0"; -"62 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/relu__0" -> "63 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"63 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "65 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"64 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "65 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"65 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "66 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"66 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "67 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/relu__0"; -"67 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/relu__0" -> "68 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"68 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "70 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"69 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "70 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"70 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "71 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"71 GoogLeNet/Inception[b3]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "72 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/relu__0"; -"72 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/relu__0" -> "73 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"73 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "80 GoogLeNet/Inception[b3]/cat_0"; -"74 GoogLeNet/Inception[b3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "76 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"75 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "76 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"76 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "77 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"77 GoogLeNet/Inception[b3]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "78 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/relu__0"; -"78 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/relu__0" -> "79 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"79 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "80 GoogLeNet/Inception[b3]/cat_0"; -"80 GoogLeNet/Inception[b3]/cat_0" -> "81 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0"; -"81 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "83 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"81 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "88 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"81 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "98 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"81 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "112 GoogLeNet/Inception[a4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"82 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "83 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"83 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "84 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"84 GoogLeNet/Inception[a4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "85 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/relu__0"; -"85 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/relu__0" -> "86 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"86 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "118 GoogLeNet/Inception[a4]/cat_0"; -"87 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "88 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"88 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "89 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"89 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "90 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/relu__0"; -"90 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/relu__0" -> "91 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"91 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "93 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"92 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "93 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"93 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "94 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"94 GoogLeNet/Inception[a4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "95 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/relu__0"; -"95 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/relu__0" -> "96 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"96 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "118 GoogLeNet/Inception[a4]/cat_0"; -"97 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "98 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"98 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "99 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"99 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "100 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/relu__0"; -"100 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/relu__0" -> "101 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"101 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "103 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"102 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "103 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"103 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "104 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"104 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "105 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/relu__0"; -"105 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/relu__0" -> "106 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"106 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "108 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"107 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "108 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"108 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "109 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"109 GoogLeNet/Inception[a4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "110 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/relu__0"; -"110 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/relu__0" -> "111 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"111 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "118 GoogLeNet/Inception[a4]/cat_0"; -"112 GoogLeNet/Inception[a4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "114 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"113 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "114 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"114 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "115 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"115 GoogLeNet/Inception[a4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "116 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/relu__0"; -"116 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/relu__0" -> "117 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"117 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "118 GoogLeNet/Inception[a4]/cat_0"; -"118 GoogLeNet/Inception[a4]/cat_0" -> "120 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"118 GoogLeNet/Inception[a4]/cat_0" -> "125 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"118 GoogLeNet/Inception[a4]/cat_0" -> "135 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"118 GoogLeNet/Inception[a4]/cat_0" -> "149 GoogLeNet/Inception[b4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"119 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "120 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"120 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "121 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"121 GoogLeNet/Inception[b4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "122 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/relu__0"; -"122 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/relu__0" -> "123 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"123 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "155 GoogLeNet/Inception[b4]/cat_0"; -"124 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "125 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"125 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "126 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"126 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "127 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/relu__0"; -"127 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/relu__0" -> "128 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"128 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "130 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"129 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "130 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"130 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "131 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"131 GoogLeNet/Inception[b4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "132 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/relu__0"; -"132 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/relu__0" -> "133 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"133 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "155 GoogLeNet/Inception[b4]/cat_0"; -"134 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "135 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"135 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "136 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"136 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "137 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/relu__0"; -"137 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/relu__0" -> "138 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"138 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "140 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"139 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "140 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"140 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "141 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"141 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "142 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/relu__0"; -"142 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/relu__0" -> "143 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"143 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "145 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"144 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "145 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"145 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "146 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"146 GoogLeNet/Inception[b4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "147 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/relu__0"; -"147 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/relu__0" -> "148 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"148 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "155 GoogLeNet/Inception[b4]/cat_0"; -"149 GoogLeNet/Inception[b4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "151 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"150 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "151 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"151 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "152 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"152 GoogLeNet/Inception[b4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "153 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/relu__0"; -"153 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/relu__0" -> "154 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"154 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "155 GoogLeNet/Inception[b4]/cat_0"; -"155 GoogLeNet/Inception[b4]/cat_0" -> "157 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"155 GoogLeNet/Inception[b4]/cat_0" -> "162 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"155 GoogLeNet/Inception[b4]/cat_0" -> "172 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"155 GoogLeNet/Inception[b4]/cat_0" -> "186 GoogLeNet/Inception[c4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"156 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "157 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"157 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "158 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"158 GoogLeNet/Inception[c4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "159 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/relu__0"; -"159 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/relu__0" -> "160 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"160 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "192 GoogLeNet/Inception[c4]/cat_0"; -"161 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "162 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"162 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "163 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"163 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "164 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/relu__0"; -"164 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/relu__0" -> "165 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"165 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "167 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"166 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "167 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"167 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "168 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"168 GoogLeNet/Inception[c4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "169 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/relu__0"; -"169 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/relu__0" -> "170 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"170 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "192 GoogLeNet/Inception[c4]/cat_0"; -"171 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "172 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"172 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "173 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"173 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "174 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/relu__0"; -"174 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/relu__0" -> "175 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"175 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "177 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"176 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "177 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"177 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "178 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"178 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "179 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/relu__0"; -"179 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/relu__0" -> "180 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"180 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "182 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"181 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "182 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"182 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "183 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"183 GoogLeNet/Inception[c4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "184 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/relu__0"; -"184 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/relu__0" -> "185 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"185 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "192 GoogLeNet/Inception[c4]/cat_0"; -"186 GoogLeNet/Inception[c4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "188 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"187 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "188 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"188 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "189 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"189 GoogLeNet/Inception[c4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "190 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/relu__0"; -"190 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/relu__0" -> "191 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"191 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "192 GoogLeNet/Inception[c4]/cat_0"; -"192 GoogLeNet/Inception[c4]/cat_0" -> "194 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"192 GoogLeNet/Inception[c4]/cat_0" -> "199 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"192 GoogLeNet/Inception[c4]/cat_0" -> "209 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"192 GoogLeNet/Inception[c4]/cat_0" -> "223 GoogLeNet/Inception[d4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"193 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "194 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"194 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "195 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"195 GoogLeNet/Inception[d4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "196 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/relu__0"; -"196 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/relu__0" -> "197 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"197 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "229 GoogLeNet/Inception[d4]/cat_0"; -"198 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "199 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"199 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "200 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"200 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "201 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/relu__0"; -"201 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/relu__0" -> "202 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"202 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "204 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"203 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "204 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"204 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "205 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"205 GoogLeNet/Inception[d4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "206 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/relu__0"; -"206 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/relu__0" -> "207 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"207 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "229 GoogLeNet/Inception[d4]/cat_0"; -"208 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "209 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"209 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "210 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"210 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "211 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/relu__0"; -"211 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/relu__0" -> "212 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"212 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "214 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"213 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "214 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"214 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "215 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"215 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "216 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/relu__0"; -"216 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/relu__0" -> "217 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"217 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "219 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"218 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "219 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"219 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "220 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"220 GoogLeNet/Inception[d4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "221 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/relu__0"; -"221 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/relu__0" -> "222 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"222 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "229 GoogLeNet/Inception[d4]/cat_0"; -"223 GoogLeNet/Inception[d4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "225 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"224 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"225 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "226 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"226 GoogLeNet/Inception[d4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "227 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/relu__0"; -"227 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/relu__0" -> "228 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"228 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "229 GoogLeNet/Inception[d4]/cat_0"; -"229 GoogLeNet/Inception[d4]/cat_0" -> "231 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"229 GoogLeNet/Inception[d4]/cat_0" -> "236 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"229 GoogLeNet/Inception[d4]/cat_0" -> "246 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"229 GoogLeNet/Inception[d4]/cat_0" -> "260 GoogLeNet/Inception[e4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"230 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "231 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"231 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "232 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"232 GoogLeNet/Inception[e4]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "233 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/relu__0"; -"233 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/relu__0" -> "234 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"234 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "266 GoogLeNet/Inception[e4]/cat_0"; -"235 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "236 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"236 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "237 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"237 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "238 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/relu__0"; -"238 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/relu__0" -> "239 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"239 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "241 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"240 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "241 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"241 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "242 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"242 GoogLeNet/Inception[e4]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "243 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/relu__0"; -"243 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/relu__0" -> "244 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"244 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "266 GoogLeNet/Inception[e4]/cat_0"; -"245 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "246 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"246 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "247 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"247 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "248 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/relu__0"; -"248 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/relu__0" -> "249 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"249 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "251 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"250 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "251 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"251 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "252 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"252 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "253 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/relu__0"; -"253 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/relu__0" -> "254 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"254 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "256 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"255 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "256 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"256 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "257 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"257 GoogLeNet/Inception[e4]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "258 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/relu__0"; -"258 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/relu__0" -> "259 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"259 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "266 GoogLeNet/Inception[e4]/cat_0"; -"260 GoogLeNet/Inception[e4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "262 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"261 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "262 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"262 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "263 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"263 GoogLeNet/Inception[e4]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "264 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/relu__0"; -"264 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/relu__0" -> "265 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"265 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "266 GoogLeNet/Inception[e4]/cat_0"; -"266 GoogLeNet/Inception[e4]/cat_0" -> "267 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1"; -"267 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "269 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"267 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "274 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"267 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "284 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"267 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "298 GoogLeNet/Inception[a5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"268 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "269 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"269 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "270 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"270 GoogLeNet/Inception[a5]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "271 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/relu__0"; -"271 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/relu__0" -> "272 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"272 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "304 GoogLeNet/Inception[a5]/cat_0"; -"273 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "274 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"274 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "275 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"275 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "276 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/relu__0"; -"276 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/relu__0" -> "277 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"277 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "279 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"278 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "279 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"279 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "280 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"280 GoogLeNet/Inception[a5]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "281 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/relu__0"; -"281 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/relu__0" -> "282 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"282 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "304 GoogLeNet/Inception[a5]/cat_0"; -"283 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "284 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"284 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "285 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"285 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "286 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/relu__0"; -"286 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/relu__0" -> "287 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"287 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "289 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"288 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "289 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"289 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "290 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"290 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "291 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/relu__0"; -"291 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/relu__0" -> "292 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"292 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "294 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"293 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "294 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"294 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "295 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"295 GoogLeNet/Inception[a5]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "296 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/relu__0"; -"296 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/relu__0" -> "297 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"297 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "304 GoogLeNet/Inception[a5]/cat_0"; -"298 GoogLeNet/Inception[a5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "300 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"299 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "300 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"300 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "301 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"301 GoogLeNet/Inception[a5]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "302 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/relu__0"; -"302 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/relu__0" -> "303 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"303 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "304 GoogLeNet/Inception[a5]/cat_0"; -"304 GoogLeNet/Inception[a5]/cat_0" -> "306 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"304 GoogLeNet/Inception[a5]/cat_0" -> "311 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"304 GoogLeNet/Inception[a5]/cat_0" -> "321 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"304 GoogLeNet/Inception[a5]/cat_0" -> "335 GoogLeNet/Inception[b5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; -"305 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "306 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0"; -"306 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFConv2d[0]/conv2d_0" -> "307 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"307 GoogLeNet/Inception[b5]/Sequential[b1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "308 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/relu__0"; -"308 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/relu__0" -> "309 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"309 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "341 GoogLeNet/Inception[b5]/cat_0"; -"310 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "311 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0"; -"311 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[0]/conv2d_0" -> "312 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"312 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "313 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/relu__0"; -"313 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/relu__0" -> "314 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"314 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "316 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"315 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "316 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0"; -"316 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFConv2d[3]/conv2d_0" -> "317 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"317 GoogLeNet/Inception[b5]/Sequential[b2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "318 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/relu__0"; -"318 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/relu__0" -> "319 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"319 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "341 GoogLeNet/Inception[b5]/cat_0"; -"320 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "321 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0"; -"321 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[0]/conv2d_0" -> "322 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"322 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "323 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/relu__0"; -"323 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/relu__0" -> "324 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"324 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "326 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"325 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "326 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0"; -"326 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[3]/conv2d_0" -> "327 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"327 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "328 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/relu__0"; -"328 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/relu__0" -> "329 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"329 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "331 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"330 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "331 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0"; -"331 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFConv2d[6]/conv2d_0" -> "332 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0"; -"332 GoogLeNet/Inception[b5]/Sequential[b3]/NNCFBatchNorm2d[7]/batch_norm_0" -> "333 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/relu__0"; -"333 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/relu__0" -> "334 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"334 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "341 GoogLeNet/Inception[b5]/cat_0"; -"335 GoogLeNet/Inception[b5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "337 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"336 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "337 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0"; -"337 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFConv2d[1]/conv2d_0" -> "338 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0"; -"338 GoogLeNet/Inception[b5]/Sequential[b4]/NNCFBatchNorm2d[2]/batch_norm_0" -> "339 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/relu__0"; -"339 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/relu__0" -> "340 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; -"340 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "341 GoogLeNet/Inception[b5]/cat_0"; -"341 GoogLeNet/Inception[b5]/cat_0" -> "342 GoogLeNet/AvgPool2d[avgpool]/avg_pool2d_0"; -"342 GoogLeNet/AvgPool2d[avgpool]/avg_pool2d_0" -> "343 GoogLeNet/AvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; -"343 GoogLeNet/AvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "344 GoogLeNet/view_0"; -"344 GoogLeNet/view_0" -> "346 GoogLeNet/NNCFLinear[linear]/linear_0"; -"345 GoogLeNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "346 GoogLeNet/NNCFLinear[linear]/linear_0"; -"346 GoogLeNet/NNCFLinear[linear]/linear_0" -> "347 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/conv2d_0"; +"2 pre_layers.0.weight" -> "4 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 pre_layers.0.bias" -> "5 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/conv2d_0"; +"4 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "5 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/conv2d_0"; +"5 GoogLeNet/Sequential[pre_layers]/Conv2d[0]/conv2d_0" -> "8 GoogLeNet/Sequential[pre_layers]/BatchNorm2d[1]/batch_norm_0"; +"6 pre_layers.1.weight" -> "8 GoogLeNet/Sequential[pre_layers]/BatchNorm2d[1]/batch_norm_0"; +"7 pre_layers.1.bias" -> "8 GoogLeNet/Sequential[pre_layers]/BatchNorm2d[1]/batch_norm_0"; +"8 GoogLeNet/Sequential[pre_layers]/BatchNorm2d[1]/batch_norm_0" -> "9 GoogLeNet/Sequential[pre_layers]/ReLU[2]/relu__0"; +"9 GoogLeNet/Sequential[pre_layers]/ReLU[2]/relu__0" -> "10 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"10 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "14 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"10 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "23 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"10 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "41 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"10 GoogLeNet/Sequential[pre_layers]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "65 GoogLeNet/Inception[a3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"11 a3.b1.0.weight" -> "13 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"12 a3.b1.0.bias" -> "14 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"13 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "14 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"14 GoogLeNet/Inception[a3]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "17 GoogLeNet/Inception[a3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"15 a3.b1.1.weight" -> "17 GoogLeNet/Inception[a3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"16 a3.b1.1.bias" -> "17 GoogLeNet/Inception[a3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"17 GoogLeNet/Inception[a3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "18 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/relu__0"; +"18 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/relu__0" -> "19 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"19 GoogLeNet/Inception[a3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "75 GoogLeNet/Inception[a3]/cat_0"; +"20 a3.b2.0.weight" -> "22 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"21 a3.b2.0.bias" -> "23 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"22 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "23 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"23 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "26 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"24 a3.b2.1.weight" -> "26 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"25 a3.b2.1.bias" -> "26 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"26 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "27 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/relu__0"; +"27 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/relu__0" -> "28 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"28 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "32 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"29 a3.b2.3.weight" -> "31 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"30 a3.b2.3.bias" -> "32 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"31 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "32 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"32 GoogLeNet/Inception[a3]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "35 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"33 a3.b2.4.weight" -> "35 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"34 a3.b2.4.bias" -> "35 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"35 GoogLeNet/Inception[a3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "36 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/relu__0"; +"36 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/relu__0" -> "37 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"37 GoogLeNet/Inception[a3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "75 GoogLeNet/Inception[a3]/cat_0"; +"38 a3.b3.0.weight" -> "40 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"39 a3.b3.0.bias" -> "41 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"40 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "41 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"41 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "44 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"42 a3.b3.1.weight" -> "44 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"43 a3.b3.1.bias" -> "44 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"44 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "45 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/relu__0"; +"45 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/relu__0" -> "46 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"46 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "50 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"47 a3.b3.3.weight" -> "49 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"48 a3.b3.3.bias" -> "50 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"49 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "50 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"50 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "53 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"51 a3.b3.4.weight" -> "53 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"52 a3.b3.4.bias" -> "53 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"53 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "54 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/relu__0"; +"54 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/relu__0" -> "55 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"55 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "59 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"56 a3.b3.6.weight" -> "58 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"57 a3.b3.6.bias" -> "59 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"58 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "59 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"59 GoogLeNet/Inception[a3]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "62 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"60 a3.b3.7.weight" -> "62 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"61 a3.b3.7.bias" -> "62 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"62 GoogLeNet/Inception[a3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "63 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/relu__0"; +"63 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/relu__0" -> "64 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"64 GoogLeNet/Inception[a3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "75 GoogLeNet/Inception[a3]/cat_0"; +"65 GoogLeNet/Inception[a3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "69 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"66 a3.b4.1.weight" -> "68 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"67 a3.b4.1.bias" -> "69 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"68 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "69 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"69 GoogLeNet/Inception[a3]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "72 GoogLeNet/Inception[a3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"70 a3.b4.2.weight" -> "72 GoogLeNet/Inception[a3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"71 a3.b4.2.bias" -> "72 GoogLeNet/Inception[a3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"72 GoogLeNet/Inception[a3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "73 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/relu__0"; +"73 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/relu__0" -> "74 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"74 GoogLeNet/Inception[a3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "75 GoogLeNet/Inception[a3]/cat_0"; +"75 GoogLeNet/Inception[a3]/cat_0" -> "79 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"75 GoogLeNet/Inception[a3]/cat_0" -> "88 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"75 GoogLeNet/Inception[a3]/cat_0" -> "106 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"75 GoogLeNet/Inception[a3]/cat_0" -> "130 GoogLeNet/Inception[b3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"76 b3.b1.0.weight" -> "78 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"77 b3.b1.0.bias" -> "79 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"78 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "79 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"79 GoogLeNet/Inception[b3]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "82 GoogLeNet/Inception[b3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"80 b3.b1.1.weight" -> "82 GoogLeNet/Inception[b3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"81 b3.b1.1.bias" -> "82 GoogLeNet/Inception[b3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"82 GoogLeNet/Inception[b3]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "83 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/relu__0"; +"83 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/relu__0" -> "84 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"84 GoogLeNet/Inception[b3]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "140 GoogLeNet/Inception[b3]/cat_0"; +"85 b3.b2.0.weight" -> "87 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"86 b3.b2.0.bias" -> "88 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"87 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "88 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"88 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "91 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"89 b3.b2.1.weight" -> "91 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"90 b3.b2.1.bias" -> "91 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"91 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "92 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/relu__0"; +"92 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/relu__0" -> "93 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"93 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "97 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"94 b3.b2.3.weight" -> "96 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"95 b3.b2.3.bias" -> "97 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"96 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "97 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"97 GoogLeNet/Inception[b3]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "100 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"98 b3.b2.4.weight" -> "100 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"99 b3.b2.4.bias" -> "100 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"100 GoogLeNet/Inception[b3]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "101 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/relu__0"; +"101 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/relu__0" -> "102 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"102 GoogLeNet/Inception[b3]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "140 GoogLeNet/Inception[b3]/cat_0"; +"103 b3.b3.0.weight" -> "105 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"104 b3.b3.0.bias" -> "106 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"105 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "106 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"106 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "109 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"107 b3.b3.1.weight" -> "109 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"108 b3.b3.1.bias" -> "109 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"109 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "110 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/relu__0"; +"110 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/relu__0" -> "111 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"111 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "115 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"112 b3.b3.3.weight" -> "114 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"113 b3.b3.3.bias" -> "115 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"114 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "115 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"115 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "118 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"116 b3.b3.4.weight" -> "118 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"117 b3.b3.4.bias" -> "118 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"118 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "119 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/relu__0"; +"119 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/relu__0" -> "120 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"120 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "124 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"121 b3.b3.6.weight" -> "123 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"122 b3.b3.6.bias" -> "124 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"123 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "124 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"124 GoogLeNet/Inception[b3]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "127 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"125 b3.b3.7.weight" -> "127 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"126 b3.b3.7.bias" -> "127 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"127 GoogLeNet/Inception[b3]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "128 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/relu__0"; +"128 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/relu__0" -> "129 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"129 GoogLeNet/Inception[b3]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "140 GoogLeNet/Inception[b3]/cat_0"; +"130 GoogLeNet/Inception[b3]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "134 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"131 b3.b4.1.weight" -> "133 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"132 b3.b4.1.bias" -> "134 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"133 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "134 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"134 GoogLeNet/Inception[b3]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "137 GoogLeNet/Inception[b3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"135 b3.b4.2.weight" -> "137 GoogLeNet/Inception[b3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"136 b3.b4.2.bias" -> "137 GoogLeNet/Inception[b3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"137 GoogLeNet/Inception[b3]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "138 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/relu__0"; +"138 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/relu__0" -> "139 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"139 GoogLeNet/Inception[b3]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "140 GoogLeNet/Inception[b3]/cat_0"; +"140 GoogLeNet/Inception[b3]/cat_0" -> "141 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0"; +"141 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "145 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"141 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "154 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"141 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "172 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"141 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_0" -> "196 GoogLeNet/Inception[a4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"142 a4.b1.0.weight" -> "144 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"143 a4.b1.0.bias" -> "145 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"144 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "145 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"145 GoogLeNet/Inception[a4]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "148 GoogLeNet/Inception[a4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"146 a4.b1.1.weight" -> "148 GoogLeNet/Inception[a4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"147 a4.b1.1.bias" -> "148 GoogLeNet/Inception[a4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"148 GoogLeNet/Inception[a4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "149 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/relu__0"; +"149 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/relu__0" -> "150 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"150 GoogLeNet/Inception[a4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "206 GoogLeNet/Inception[a4]/cat_0"; +"151 a4.b2.0.weight" -> "153 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"152 a4.b2.0.bias" -> "154 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"153 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "154 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"154 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "157 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"155 a4.b2.1.weight" -> "157 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"156 a4.b2.1.bias" -> "157 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"157 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "158 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/relu__0"; +"158 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/relu__0" -> "159 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"159 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "163 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"160 a4.b2.3.weight" -> "162 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"161 a4.b2.3.bias" -> "163 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"162 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "163 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"163 GoogLeNet/Inception[a4]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "166 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"164 a4.b2.4.weight" -> "166 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"165 a4.b2.4.bias" -> "166 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"166 GoogLeNet/Inception[a4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "167 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/relu__0"; +"167 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/relu__0" -> "168 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"168 GoogLeNet/Inception[a4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "206 GoogLeNet/Inception[a4]/cat_0"; +"169 a4.b3.0.weight" -> "171 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"170 a4.b3.0.bias" -> "172 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"171 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "172 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"172 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "175 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"173 a4.b3.1.weight" -> "175 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"174 a4.b3.1.bias" -> "175 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"175 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "176 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/relu__0"; +"176 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/relu__0" -> "177 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"177 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "181 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"178 a4.b3.3.weight" -> "180 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"179 a4.b3.3.bias" -> "181 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"180 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "181 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"181 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "184 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"182 a4.b3.4.weight" -> "184 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"183 a4.b3.4.bias" -> "184 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"184 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "185 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/relu__0"; +"185 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/relu__0" -> "186 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"186 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "190 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"187 a4.b3.6.weight" -> "189 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"188 a4.b3.6.bias" -> "190 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"189 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "190 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"190 GoogLeNet/Inception[a4]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "193 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"191 a4.b3.7.weight" -> "193 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"192 a4.b3.7.bias" -> "193 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"193 GoogLeNet/Inception[a4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "194 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/relu__0"; +"194 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/relu__0" -> "195 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"195 GoogLeNet/Inception[a4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "206 GoogLeNet/Inception[a4]/cat_0"; +"196 GoogLeNet/Inception[a4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "200 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"197 a4.b4.1.weight" -> "199 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"198 a4.b4.1.bias" -> "200 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"199 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "200 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"200 GoogLeNet/Inception[a4]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "203 GoogLeNet/Inception[a4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"201 a4.b4.2.weight" -> "203 GoogLeNet/Inception[a4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"202 a4.b4.2.bias" -> "203 GoogLeNet/Inception[a4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"203 GoogLeNet/Inception[a4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "204 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/relu__0"; +"204 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/relu__0" -> "205 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"205 GoogLeNet/Inception[a4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "206 GoogLeNet/Inception[a4]/cat_0"; +"206 GoogLeNet/Inception[a4]/cat_0" -> "210 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"206 GoogLeNet/Inception[a4]/cat_0" -> "219 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"206 GoogLeNet/Inception[a4]/cat_0" -> "237 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"206 GoogLeNet/Inception[a4]/cat_0" -> "261 GoogLeNet/Inception[b4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"207 b4.b1.0.weight" -> "209 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"208 b4.b1.0.bias" -> "210 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"209 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "210 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"210 GoogLeNet/Inception[b4]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "213 GoogLeNet/Inception[b4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"211 b4.b1.1.weight" -> "213 GoogLeNet/Inception[b4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"212 b4.b1.1.bias" -> "213 GoogLeNet/Inception[b4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"213 GoogLeNet/Inception[b4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "214 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/relu__0"; +"214 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/relu__0" -> "215 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"215 GoogLeNet/Inception[b4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "271 GoogLeNet/Inception[b4]/cat_0"; +"216 b4.b2.0.weight" -> "218 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"217 b4.b2.0.bias" -> "219 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"218 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "219 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"219 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "222 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"220 b4.b2.1.weight" -> "222 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"221 b4.b2.1.bias" -> "222 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"222 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "223 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/relu__0"; +"223 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/relu__0" -> "224 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"224 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "228 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"225 b4.b2.3.weight" -> "227 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"226 b4.b2.3.bias" -> "228 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"227 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "228 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"228 GoogLeNet/Inception[b4]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "231 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"229 b4.b2.4.weight" -> "231 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"230 b4.b2.4.bias" -> "231 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"231 GoogLeNet/Inception[b4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "232 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/relu__0"; +"232 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/relu__0" -> "233 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"233 GoogLeNet/Inception[b4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "271 GoogLeNet/Inception[b4]/cat_0"; +"234 b4.b3.0.weight" -> "236 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"235 b4.b3.0.bias" -> "237 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"236 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "237 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"237 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "240 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"238 b4.b3.1.weight" -> "240 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"239 b4.b3.1.bias" -> "240 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"240 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "241 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/relu__0"; +"241 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/relu__0" -> "242 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"242 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "246 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"243 b4.b3.3.weight" -> "245 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"244 b4.b3.3.bias" -> "246 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"245 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "246 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"246 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "249 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"247 b4.b3.4.weight" -> "249 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"248 b4.b3.4.bias" -> "249 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"249 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "250 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/relu__0"; +"250 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/relu__0" -> "251 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"251 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "255 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"252 b4.b3.6.weight" -> "254 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"253 b4.b3.6.bias" -> "255 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"254 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "255 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"255 GoogLeNet/Inception[b4]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "258 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"256 b4.b3.7.weight" -> "258 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"257 b4.b3.7.bias" -> "258 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"258 GoogLeNet/Inception[b4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "259 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/relu__0"; +"259 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/relu__0" -> "260 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"260 GoogLeNet/Inception[b4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "271 GoogLeNet/Inception[b4]/cat_0"; +"261 GoogLeNet/Inception[b4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "265 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"262 b4.b4.1.weight" -> "264 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"263 b4.b4.1.bias" -> "265 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"264 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "265 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"265 GoogLeNet/Inception[b4]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "268 GoogLeNet/Inception[b4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"266 b4.b4.2.weight" -> "268 GoogLeNet/Inception[b4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"267 b4.b4.2.bias" -> "268 GoogLeNet/Inception[b4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"268 GoogLeNet/Inception[b4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "269 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/relu__0"; +"269 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/relu__0" -> "270 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"270 GoogLeNet/Inception[b4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "271 GoogLeNet/Inception[b4]/cat_0"; +"271 GoogLeNet/Inception[b4]/cat_0" -> "275 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"271 GoogLeNet/Inception[b4]/cat_0" -> "284 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"271 GoogLeNet/Inception[b4]/cat_0" -> "302 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"271 GoogLeNet/Inception[b4]/cat_0" -> "326 GoogLeNet/Inception[c4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"272 c4.b1.0.weight" -> "274 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"273 c4.b1.0.bias" -> "275 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"274 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "275 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"275 GoogLeNet/Inception[c4]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "278 GoogLeNet/Inception[c4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"276 c4.b1.1.weight" -> "278 GoogLeNet/Inception[c4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"277 c4.b1.1.bias" -> "278 GoogLeNet/Inception[c4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"278 GoogLeNet/Inception[c4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "279 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/relu__0"; +"279 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/relu__0" -> "280 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"280 GoogLeNet/Inception[c4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "336 GoogLeNet/Inception[c4]/cat_0"; +"281 c4.b2.0.weight" -> "283 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"282 c4.b2.0.bias" -> "284 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"283 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "284 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"284 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "287 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"285 c4.b2.1.weight" -> "287 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"286 c4.b2.1.bias" -> "287 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"287 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "288 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/relu__0"; +"288 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/relu__0" -> "289 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"289 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "293 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"290 c4.b2.3.weight" -> "292 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"291 c4.b2.3.bias" -> "293 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"292 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "293 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"293 GoogLeNet/Inception[c4]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "296 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"294 c4.b2.4.weight" -> "296 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"295 c4.b2.4.bias" -> "296 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"296 GoogLeNet/Inception[c4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "297 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/relu__0"; +"297 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/relu__0" -> "298 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"298 GoogLeNet/Inception[c4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "336 GoogLeNet/Inception[c4]/cat_0"; +"299 c4.b3.0.weight" -> "301 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"300 c4.b3.0.bias" -> "302 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"301 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "302 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"302 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "305 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"303 c4.b3.1.weight" -> "305 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"304 c4.b3.1.bias" -> "305 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"305 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "306 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/relu__0"; +"306 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/relu__0" -> "307 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"307 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "311 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"308 c4.b3.3.weight" -> "310 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"309 c4.b3.3.bias" -> "311 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"310 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "311 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"311 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "314 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"312 c4.b3.4.weight" -> "314 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"313 c4.b3.4.bias" -> "314 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"314 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "315 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/relu__0"; +"315 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/relu__0" -> "316 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"316 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "320 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"317 c4.b3.6.weight" -> "319 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"318 c4.b3.6.bias" -> "320 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"319 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "320 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"320 GoogLeNet/Inception[c4]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "323 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"321 c4.b3.7.weight" -> "323 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"322 c4.b3.7.bias" -> "323 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"323 GoogLeNet/Inception[c4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "324 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/relu__0"; +"324 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/relu__0" -> "325 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"325 GoogLeNet/Inception[c4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "336 GoogLeNet/Inception[c4]/cat_0"; +"326 GoogLeNet/Inception[c4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "330 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"327 c4.b4.1.weight" -> "329 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"328 c4.b4.1.bias" -> "330 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"329 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "330 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"330 GoogLeNet/Inception[c4]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "333 GoogLeNet/Inception[c4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"331 c4.b4.2.weight" -> "333 GoogLeNet/Inception[c4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"332 c4.b4.2.bias" -> "333 GoogLeNet/Inception[c4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"333 GoogLeNet/Inception[c4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "334 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/relu__0"; +"334 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/relu__0" -> "335 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"335 GoogLeNet/Inception[c4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "336 GoogLeNet/Inception[c4]/cat_0"; +"336 GoogLeNet/Inception[c4]/cat_0" -> "340 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"336 GoogLeNet/Inception[c4]/cat_0" -> "349 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"336 GoogLeNet/Inception[c4]/cat_0" -> "367 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"336 GoogLeNet/Inception[c4]/cat_0" -> "391 GoogLeNet/Inception[d4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"337 d4.b1.0.weight" -> "339 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"338 d4.b1.0.bias" -> "340 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"339 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "340 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"340 GoogLeNet/Inception[d4]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "343 GoogLeNet/Inception[d4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"341 d4.b1.1.weight" -> "343 GoogLeNet/Inception[d4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"342 d4.b1.1.bias" -> "343 GoogLeNet/Inception[d4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"343 GoogLeNet/Inception[d4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "344 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/relu__0"; +"344 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/relu__0" -> "345 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"345 GoogLeNet/Inception[d4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "401 GoogLeNet/Inception[d4]/cat_0"; +"346 d4.b2.0.weight" -> "348 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"347 d4.b2.0.bias" -> "349 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"348 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "349 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"349 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "352 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"350 d4.b2.1.weight" -> "352 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"351 d4.b2.1.bias" -> "352 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"352 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "353 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/relu__0"; +"353 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/relu__0" -> "354 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"354 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "358 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"355 d4.b2.3.weight" -> "357 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"356 d4.b2.3.bias" -> "358 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"357 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "358 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"358 GoogLeNet/Inception[d4]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "361 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"359 d4.b2.4.weight" -> "361 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"360 d4.b2.4.bias" -> "361 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"361 GoogLeNet/Inception[d4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "362 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/relu__0"; +"362 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/relu__0" -> "363 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"363 GoogLeNet/Inception[d4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "401 GoogLeNet/Inception[d4]/cat_0"; +"364 d4.b3.0.weight" -> "366 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"365 d4.b3.0.bias" -> "367 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"366 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "367 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"367 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "370 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"368 d4.b3.1.weight" -> "370 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"369 d4.b3.1.bias" -> "370 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"370 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "371 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/relu__0"; +"371 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/relu__0" -> "372 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"372 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "376 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"373 d4.b3.3.weight" -> "375 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"374 d4.b3.3.bias" -> "376 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"375 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "376 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"376 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "379 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"377 d4.b3.4.weight" -> "379 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"378 d4.b3.4.bias" -> "379 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"379 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "380 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/relu__0"; +"380 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/relu__0" -> "381 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"381 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "385 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"382 d4.b3.6.weight" -> "384 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"383 d4.b3.6.bias" -> "385 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"384 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "385 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"385 GoogLeNet/Inception[d4]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "388 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"386 d4.b3.7.weight" -> "388 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"387 d4.b3.7.bias" -> "388 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"388 GoogLeNet/Inception[d4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "389 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/relu__0"; +"389 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/relu__0" -> "390 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"390 GoogLeNet/Inception[d4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "401 GoogLeNet/Inception[d4]/cat_0"; +"391 GoogLeNet/Inception[d4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "395 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"392 d4.b4.1.weight" -> "394 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"393 d4.b4.1.bias" -> "395 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"394 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "395 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"395 GoogLeNet/Inception[d4]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "398 GoogLeNet/Inception[d4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"396 d4.b4.2.weight" -> "398 GoogLeNet/Inception[d4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"397 d4.b4.2.bias" -> "398 GoogLeNet/Inception[d4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"398 GoogLeNet/Inception[d4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "399 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/relu__0"; +"399 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/relu__0" -> "400 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"400 GoogLeNet/Inception[d4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "401 GoogLeNet/Inception[d4]/cat_0"; +"401 GoogLeNet/Inception[d4]/cat_0" -> "405 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"401 GoogLeNet/Inception[d4]/cat_0" -> "414 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"401 GoogLeNet/Inception[d4]/cat_0" -> "432 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"401 GoogLeNet/Inception[d4]/cat_0" -> "456 GoogLeNet/Inception[e4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"402 e4.b1.0.weight" -> "404 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"403 e4.b1.0.bias" -> "405 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"404 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "405 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"405 GoogLeNet/Inception[e4]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "408 GoogLeNet/Inception[e4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"406 e4.b1.1.weight" -> "408 GoogLeNet/Inception[e4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"407 e4.b1.1.bias" -> "408 GoogLeNet/Inception[e4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"408 GoogLeNet/Inception[e4]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "409 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/relu__0"; +"409 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/relu__0" -> "410 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"410 GoogLeNet/Inception[e4]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "466 GoogLeNet/Inception[e4]/cat_0"; +"411 e4.b2.0.weight" -> "413 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"412 e4.b2.0.bias" -> "414 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"413 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "414 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"414 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "417 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"415 e4.b2.1.weight" -> "417 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"416 e4.b2.1.bias" -> "417 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"417 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "418 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/relu__0"; +"418 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/relu__0" -> "419 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"419 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "423 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"420 e4.b2.3.weight" -> "422 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"421 e4.b2.3.bias" -> "423 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"422 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "423 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"423 GoogLeNet/Inception[e4]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "426 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"424 e4.b2.4.weight" -> "426 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"425 e4.b2.4.bias" -> "426 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"426 GoogLeNet/Inception[e4]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "427 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/relu__0"; +"427 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/relu__0" -> "428 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"428 GoogLeNet/Inception[e4]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "466 GoogLeNet/Inception[e4]/cat_0"; +"429 e4.b3.0.weight" -> "431 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"430 e4.b3.0.bias" -> "432 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"431 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "432 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"432 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "435 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"433 e4.b3.1.weight" -> "435 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"434 e4.b3.1.bias" -> "435 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"435 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "436 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/relu__0"; +"436 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/relu__0" -> "437 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"437 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "441 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"438 e4.b3.3.weight" -> "440 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"439 e4.b3.3.bias" -> "441 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"440 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "441 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"441 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "444 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"442 e4.b3.4.weight" -> "444 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"443 e4.b3.4.bias" -> "444 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"444 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "445 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/relu__0"; +"445 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/relu__0" -> "446 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"446 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "450 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"447 e4.b3.6.weight" -> "449 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"448 e4.b3.6.bias" -> "450 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"449 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "450 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"450 GoogLeNet/Inception[e4]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "453 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"451 e4.b3.7.weight" -> "453 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"452 e4.b3.7.bias" -> "453 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"453 GoogLeNet/Inception[e4]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "454 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/relu__0"; +"454 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/relu__0" -> "455 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"455 GoogLeNet/Inception[e4]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "466 GoogLeNet/Inception[e4]/cat_0"; +"456 GoogLeNet/Inception[e4]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "460 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"457 e4.b4.1.weight" -> "459 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"458 e4.b4.1.bias" -> "460 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"459 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "460 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"460 GoogLeNet/Inception[e4]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "463 GoogLeNet/Inception[e4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"461 e4.b4.2.weight" -> "463 GoogLeNet/Inception[e4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"462 e4.b4.2.bias" -> "463 GoogLeNet/Inception[e4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"463 GoogLeNet/Inception[e4]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "464 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/relu__0"; +"464 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/relu__0" -> "465 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"465 GoogLeNet/Inception[e4]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "466 GoogLeNet/Inception[e4]/cat_0"; +"466 GoogLeNet/Inception[e4]/cat_0" -> "467 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1"; +"467 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "471 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"467 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "480 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"467 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "498 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"467 GoogLeNet/MaxPool2d[maxpool]/max_pool2d_1" -> "522 GoogLeNet/Inception[a5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"468 a5.b1.0.weight" -> "470 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"469 a5.b1.0.bias" -> "471 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"470 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "471 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"471 GoogLeNet/Inception[a5]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "474 GoogLeNet/Inception[a5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"472 a5.b1.1.weight" -> "474 GoogLeNet/Inception[a5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"473 a5.b1.1.bias" -> "474 GoogLeNet/Inception[a5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"474 GoogLeNet/Inception[a5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "475 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/relu__0"; +"475 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/relu__0" -> "476 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"476 GoogLeNet/Inception[a5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "532 GoogLeNet/Inception[a5]/cat_0"; +"477 a5.b2.0.weight" -> "479 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"478 a5.b2.0.bias" -> "480 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"479 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "480 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"480 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "483 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"481 a5.b2.1.weight" -> "483 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"482 a5.b2.1.bias" -> "483 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"483 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "484 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/relu__0"; +"484 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/relu__0" -> "485 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"485 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "489 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"486 a5.b2.3.weight" -> "488 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"487 a5.b2.3.bias" -> "489 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"488 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "489 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"489 GoogLeNet/Inception[a5]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "492 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"490 a5.b2.4.weight" -> "492 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"491 a5.b2.4.bias" -> "492 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"492 GoogLeNet/Inception[a5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "493 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/relu__0"; +"493 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/relu__0" -> "494 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"494 GoogLeNet/Inception[a5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "532 GoogLeNet/Inception[a5]/cat_0"; +"495 a5.b3.0.weight" -> "497 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"496 a5.b3.0.bias" -> "498 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"497 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "498 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"498 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "501 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"499 a5.b3.1.weight" -> "501 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"500 a5.b3.1.bias" -> "501 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"501 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "502 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/relu__0"; +"502 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/relu__0" -> "503 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"503 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "507 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"504 a5.b3.3.weight" -> "506 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"505 a5.b3.3.bias" -> "507 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"506 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "507 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"507 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "510 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"508 a5.b3.4.weight" -> "510 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"509 a5.b3.4.bias" -> "510 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"510 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "511 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/relu__0"; +"511 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/relu__0" -> "512 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"512 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "516 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"513 a5.b3.6.weight" -> "515 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"514 a5.b3.6.bias" -> "516 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"515 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "516 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"516 GoogLeNet/Inception[a5]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "519 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"517 a5.b3.7.weight" -> "519 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"518 a5.b3.7.bias" -> "519 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"519 GoogLeNet/Inception[a5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "520 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/relu__0"; +"520 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/relu__0" -> "521 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"521 GoogLeNet/Inception[a5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "532 GoogLeNet/Inception[a5]/cat_0"; +"522 GoogLeNet/Inception[a5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "526 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"523 a5.b4.1.weight" -> "525 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"524 a5.b4.1.bias" -> "526 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"525 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "526 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"526 GoogLeNet/Inception[a5]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "529 GoogLeNet/Inception[a5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"527 a5.b4.2.weight" -> "529 GoogLeNet/Inception[a5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"528 a5.b4.2.bias" -> "529 GoogLeNet/Inception[a5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"529 GoogLeNet/Inception[a5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "530 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/relu__0"; +"530 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/relu__0" -> "531 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"531 GoogLeNet/Inception[a5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "532 GoogLeNet/Inception[a5]/cat_0"; +"532 GoogLeNet/Inception[a5]/cat_0" -> "536 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"532 GoogLeNet/Inception[a5]/cat_0" -> "545 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"532 GoogLeNet/Inception[a5]/cat_0" -> "563 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"532 GoogLeNet/Inception[a5]/cat_0" -> "587 GoogLeNet/Inception[b5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0"; +"533 b5.b1.0.weight" -> "535 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"534 b5.b1.0.bias" -> "536 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"535 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "536 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/conv2d_0"; +"536 GoogLeNet/Inception[b5]/Sequential[b1]/Conv2d[0]/conv2d_0" -> "539 GoogLeNet/Inception[b5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"537 b5.b1.1.weight" -> "539 GoogLeNet/Inception[b5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"538 b5.b1.1.bias" -> "539 GoogLeNet/Inception[b5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0"; +"539 GoogLeNet/Inception[b5]/Sequential[b1]/BatchNorm2d[1]/batch_norm_0" -> "540 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/relu__0"; +"540 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/relu__0" -> "541 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"541 GoogLeNet/Inception[b5]/Sequential[b1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "597 GoogLeNet/Inception[b5]/cat_0"; +"542 b5.b2.0.weight" -> "544 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"543 b5.b2.0.bias" -> "545 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"544 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "545 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/conv2d_0"; +"545 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[0]/conv2d_0" -> "548 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"546 b5.b2.1.weight" -> "548 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"547 b5.b2.1.bias" -> "548 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0"; +"548 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[1]/batch_norm_0" -> "549 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/relu__0"; +"549 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/relu__0" -> "550 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"550 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "554 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"551 b5.b2.3.weight" -> "553 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"552 b5.b2.3.bias" -> "554 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"553 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "554 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/conv2d_0"; +"554 GoogLeNet/Inception[b5]/Sequential[b2]/Conv2d[3]/conv2d_0" -> "557 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"555 b5.b2.4.weight" -> "557 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"556 b5.b2.4.bias" -> "557 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0"; +"557 GoogLeNet/Inception[b5]/Sequential[b2]/BatchNorm2d[4]/batch_norm_0" -> "558 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/relu__0"; +"558 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/relu__0" -> "559 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"559 GoogLeNet/Inception[b5]/Sequential[b2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "597 GoogLeNet/Inception[b5]/cat_0"; +"560 b5.b3.0.weight" -> "562 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"561 b5.b3.0.bias" -> "563 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"562 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "563 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/conv2d_0"; +"563 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[0]/conv2d_0" -> "566 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"564 b5.b3.1.weight" -> "566 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"565 b5.b3.1.bias" -> "566 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0"; +"566 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[1]/batch_norm_0" -> "567 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/relu__0"; +"567 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/relu__0" -> "568 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"568 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "572 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"569 b5.b3.3.weight" -> "571 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"570 b5.b3.3.bias" -> "572 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"571 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "572 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/conv2d_0"; +"572 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[3]/conv2d_0" -> "575 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"573 b5.b3.4.weight" -> "575 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"574 b5.b3.4.bias" -> "575 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0"; +"575 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[4]/batch_norm_0" -> "576 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/relu__0"; +"576 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/relu__0" -> "577 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"577 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "581 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"578 b5.b3.6.weight" -> "580 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"579 b5.b3.6.bias" -> "581 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"580 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "581 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/conv2d_0"; +"581 GoogLeNet/Inception[b5]/Sequential[b3]/Conv2d[6]/conv2d_0" -> "584 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"582 b5.b3.7.weight" -> "584 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"583 b5.b3.7.bias" -> "584 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0"; +"584 GoogLeNet/Inception[b5]/Sequential[b3]/BatchNorm2d[7]/batch_norm_0" -> "585 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/relu__0"; +"585 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/relu__0" -> "586 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"586 GoogLeNet/Inception[b5]/Sequential[b3]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "597 GoogLeNet/Inception[b5]/cat_0"; +"587 GoogLeNet/Inception[b5]/Sequential[b4]/MaxPool2d[0]/max_pool2d_0" -> "591 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"588 b5.b4.1.weight" -> "590 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"589 b5.b4.1.bias" -> "591 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"590 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "591 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/conv2d_0"; +"591 GoogLeNet/Inception[b5]/Sequential[b4]/Conv2d[1]/conv2d_0" -> "594 GoogLeNet/Inception[b5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"592 b5.b4.2.weight" -> "594 GoogLeNet/Inception[b5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"593 b5.b4.2.bias" -> "594 GoogLeNet/Inception[b5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0"; +"594 GoogLeNet/Inception[b5]/Sequential[b4]/BatchNorm2d[2]/batch_norm_0" -> "595 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/relu__0"; +"595 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/relu__0" -> "596 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0"; +"596 GoogLeNet/Inception[b5]/Sequential[b4]/ReLU[3]/SymmetricQuantizer/symmetric_quantize_0" -> "597 GoogLeNet/Inception[b5]/cat_0"; +"597 GoogLeNet/Inception[b5]/cat_0" -> "598 GoogLeNet/AvgPool2d[avgpool]/avg_pool2d_0"; +"598 GoogLeNet/AvgPool2d[avgpool]/avg_pool2d_0" -> "599 GoogLeNet/AvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; +"599 GoogLeNet/AvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "600 GoogLeNet/view_0"; +"600 GoogLeNet/view_0" -> "604 GoogLeNet/Linear[linear]/linear_0"; +"601 linear.weight" -> "603 GoogLeNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0"; +"602 linear.bias" -> "604 GoogLeNet/Linear[linear]/linear_0"; +"603 GoogLeNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" -> "604 GoogLeNet/Linear[linear]/linear_0"; +"604 GoogLeNet/Linear[linear]/linear_0" -> "605 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception_v3.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception_v3.dot index 1082c9c5847..b618d750fba 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception_v3.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/inception_v3.dot @@ -20,520 +20,804 @@ strict digraph { "18 Inception3/__add___2" [id=18, type=__add__]; "19 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/__add___0|OUTPUT;Inception3/__add___1|OUTPUT;Inception3/__add___2|OUTPUT]/symmetric_quantize_2" [id=19, type=symmetric_quantize]; "20 Inception3/cat_0" [id=20, type=cat]; -"21 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d_0" [id=22, type=conv2d]; -"23 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=23, type=batch_norm]; -"24 Inception3/BasicConv2d[Conv2d_1a_3x3]/relu__0" [id=24, type=relu_]; -"25 Inception3/BasicConv2d[Conv2d_1a_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=26, type=symmetric_quantize]; -"27 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d_0" [id=27, type=conv2d]; -"28 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=28, type=batch_norm]; -"29 Inception3/BasicConv2d[Conv2d_2a_3x3]/relu__0" [id=29, type=relu_]; -"30 Inception3/BasicConv2d[Conv2d_2a_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; -"31 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=31, type=symmetric_quantize]; -"32 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d_0" [id=32, type=conv2d]; -"33 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=33, type=batch_norm]; -"34 Inception3/BasicConv2d[Conv2d_2b_3x3]/relu__0" [id=34, type=relu_]; -"35 Inception3/BasicConv2d[Conv2d_2b_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=35, type=symmetric_quantize]; -"36 Inception3/max_pool2d_0" [id=36, type=max_pool2d]; -"37 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=37, type=symmetric_quantize]; -"38 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d_0" [id=38, type=conv2d]; -"39 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=39, type=batch_norm]; -"40 Inception3/BasicConv2d[Conv2d_3b_1x1]/relu__0" [id=40, type=relu_]; -"41 Inception3/BasicConv2d[Conv2d_3b_1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=41, type=symmetric_quantize]; -"42 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=42, type=symmetric_quantize]; -"43 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d_0" [id=43, type=conv2d]; -"44 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=44, type=batch_norm]; -"45 Inception3/BasicConv2d[Conv2d_4a_3x3]/relu__0" [id=45, type=relu_]; -"46 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=46, type=symmetric_quantize]; -"47 Inception3/max_pool2d_1" [id=47, type=max_pool2d]; -"48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=48, type=symmetric_quantize]; -"49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=49, type=conv2d]; -"50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=50, type=batch_norm]; -"51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/relu__0" [id=51, type=relu_]; -"52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; -"53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=53, type=symmetric_quantize]; -"54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0" [id=54, type=conv2d]; -"55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=55, type=batch_norm]; -"56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/relu__0" [id=56, type=relu_]; -"57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" [id=57, type=symmetric_quantize]; -"58 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=58, type=symmetric_quantize]; -"59 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0" [id=59, type=conv2d]; -"60 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=60, type=batch_norm]; -"61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/relu__0" [id=61, type=relu_]; -"62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" [id=62, type=symmetric_quantize]; -"63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=63, type=symmetric_quantize]; -"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=64, type=conv2d]; -"65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=65, type=batch_norm]; -"66 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=66, type=relu_]; -"67 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=67, type=symmetric_quantize]; -"68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=68, type=symmetric_quantize]; -"69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=69, type=conv2d]; -"70 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=70, type=batch_norm]; -"71 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=71, type=relu_]; -"72 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=72, type=symmetric_quantize]; -"73 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=74, type=conv2d]; -"75 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=75, type=batch_norm]; -"76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=76, type=relu_]; -"77 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=77, type=symmetric_quantize]; -"78 Inception3/InceptionA[Mixed_5b]/avg_pool2d_0" [id=78, type=avg_pool2d]; -"79 Inception3/InceptionA[Mixed_5b]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; -"80 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=81, type=conv2d]; -"82 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=82, type=batch_norm]; -"83 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/relu__0" [id=83, type=relu_]; -"84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; -"85 Inception3/InceptionA[Mixed_5b]/cat_0" [id=85, type=cat]; -"86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=86, type=symmetric_quantize]; -"87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=87, type=conv2d]; -"88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=88, type=batch_norm]; -"89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/relu__0" [id=89, type=relu_]; -"90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=90, type=symmetric_quantize]; -"91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0" [id=92, type=conv2d]; -"93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=93, type=batch_norm]; -"94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/relu__0" [id=94, type=relu_]; -"95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" [id=95, type=symmetric_quantize]; -"96 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0" [id=97, type=conv2d]; -"98 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=98, type=batch_norm]; -"99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/relu__0" [id=99, type=relu_]; -"100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=101, type=symmetric_quantize]; -"102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=102, type=conv2d]; -"103 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=103, type=batch_norm]; -"104 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=104, type=relu_]; -"105 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; -"106 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=106, type=symmetric_quantize]; -"107 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=107, type=conv2d]; -"108 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=108, type=batch_norm]; -"109 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=109, type=relu_]; -"110 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; -"111 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=112, type=conv2d]; -"113 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=113, type=batch_norm]; -"114 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=114, type=relu_]; -"115 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=115, type=symmetric_quantize]; -"116 Inception3/InceptionA[Mixed_5c]/avg_pool2d_0" [id=116, type=avg_pool2d]; -"117 Inception3/InceptionA[Mixed_5c]/SymmetricQuantizer/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=118, type=symmetric_quantize]; -"119 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=119, type=conv2d]; -"120 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=120, type=batch_norm]; -"121 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/relu__0" [id=121, type=relu_]; -"122 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; -"123 Inception3/InceptionA[Mixed_5c]/cat_0" [id=123, type=cat]; -"124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=124, type=symmetric_quantize]; -"125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=125, type=conv2d]; -"126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=126, type=batch_norm]; -"127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/relu__0" [id=127, type=relu_]; -"128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=128, type=symmetric_quantize]; -"129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=129, type=symmetric_quantize]; -"130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0" [id=130, type=conv2d]; -"131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=131, type=batch_norm]; -"132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/relu__0" [id=132, type=relu_]; -"133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" [id=133, type=symmetric_quantize]; -"134 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=134, type=symmetric_quantize]; -"135 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0" [id=135, type=conv2d]; -"136 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=136, type=batch_norm]; -"137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/relu__0" [id=137, type=relu_]; -"138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" [id=138, type=symmetric_quantize]; -"139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=139, type=symmetric_quantize]; -"140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=140, type=conv2d]; -"141 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=141, type=batch_norm]; -"142 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=142, type=relu_]; -"143 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=143, type=symmetric_quantize]; -"144 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=144, type=symmetric_quantize]; -"145 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=145, type=conv2d]; -"146 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=146, type=batch_norm]; -"147 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=147, type=relu_]; -"148 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=149, type=symmetric_quantize]; -"150 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=150, type=conv2d]; -"151 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=151, type=batch_norm]; -"152 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=152, type=relu_]; -"153 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=153, type=symmetric_quantize]; -"154 Inception3/InceptionA[Mixed_5d]/avg_pool2d_0" [id=154, type=avg_pool2d]; -"155 Inception3/InceptionA[Mixed_5d]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; -"156 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=156, type=symmetric_quantize]; -"157 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=157, type=conv2d]; -"158 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=158, type=batch_norm]; -"159 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/relu__0" [id=159, type=relu_]; -"160 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=160, type=symmetric_quantize]; -"161 Inception3/InceptionA[Mixed_5d]/cat_0" [id=161, type=cat]; -"162 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=162, type=symmetric_quantize]; -"163 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d_0" [id=163, type=conv2d]; -"164 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=164, type=batch_norm]; -"165 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/relu__0" [id=165, type=relu_]; -"166 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=166, type=symmetric_quantize]; -"167 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=167, type=symmetric_quantize]; -"168 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=168, type=conv2d]; -"169 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=169, type=batch_norm]; -"170 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=170, type=relu_]; -"171 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=171, type=symmetric_quantize]; -"172 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=172, type=symmetric_quantize]; -"173 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=173, type=conv2d]; -"174 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=174, type=batch_norm]; -"175 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=175, type=relu_]; -"176 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=176, type=symmetric_quantize]; -"177 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=177, type=symmetric_quantize]; -"178 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=178, type=conv2d]; -"179 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=179, type=batch_norm]; -"180 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=180, type=relu_]; -"181 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=181, type=symmetric_quantize]; -"182 Inception3/InceptionB[Mixed_6a]/max_pool2d_0" [id=182, type=max_pool2d]; -"183 Inception3/InceptionB[Mixed_6a]/cat_0" [id=183, type=cat]; -"184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=184, type=symmetric_quantize]; -"185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=185, type=conv2d]; -"186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=186, type=batch_norm]; -"187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/relu__0" [id=187, type=relu_]; -"188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; -"189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=189, type=symmetric_quantize]; -"190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" [id=190, type=conv2d]; -"191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=191, type=batch_norm]; -"192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/relu__0" [id=192, type=relu_]; -"193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; -"194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=194, type=symmetric_quantize]; -"195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" [id=195, type=conv2d]; -"196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=196, type=batch_norm]; -"197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/relu__0" [id=197, type=relu_]; -"198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; -"199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=199, type=symmetric_quantize]; -"200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" [id=200, type=conv2d]; -"201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=201, type=batch_norm]; -"202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/relu__0" [id=202, type=relu_]; -"203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; -"204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=204, type=symmetric_quantize]; -"205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=205, type=conv2d]; -"206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=206, type=batch_norm]; -"207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=207, type=relu_]; -"208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=208, type=symmetric_quantize]; -"209 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=209, type=symmetric_quantize]; -"210 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=210, type=conv2d]; -"211 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=211, type=batch_norm]; -"212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=212, type=relu_]; -"213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=213, type=symmetric_quantize]; -"214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=214, type=symmetric_quantize]; -"215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=215, type=conv2d]; -"216 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=216, type=batch_norm]; -"217 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=217, type=relu_]; -"218 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=218, type=symmetric_quantize]; -"219 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=219, type=symmetric_quantize]; -"220 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" [id=220, type=conv2d]; -"221 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=221, type=batch_norm]; -"222 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=222, type=relu_]; -"223 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; -"224 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; -"225 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" [id=225, type=conv2d]; -"226 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=226, type=batch_norm]; -"227 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=227, type=relu_]; -"228 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; -"229 Inception3/InceptionC[Mixed_6b]/avg_pool2d_0" [id=229, type=avg_pool2d]; -"230 Inception3/InceptionC[Mixed_6b]/SymmetricQuantizer/symmetric_quantize_0" [id=230, type=symmetric_quantize]; -"231 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=231, type=symmetric_quantize]; -"232 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=232, type=conv2d]; -"233 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=233, type=batch_norm]; -"234 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/relu__0" [id=234, type=relu_]; -"235 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=235, type=symmetric_quantize]; -"236 Inception3/InceptionC[Mixed_6b]/cat_0" [id=236, type=cat]; -"237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=237, type=symmetric_quantize]; -"238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=238, type=conv2d]; -"239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=239, type=batch_norm]; -"240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/relu__0" [id=240, type=relu_]; -"241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=241, type=symmetric_quantize]; -"242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=242, type=symmetric_quantize]; -"243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" [id=243, type=conv2d]; -"244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=244, type=batch_norm]; -"245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/relu__0" [id=245, type=relu_]; -"246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=246, type=symmetric_quantize]; -"247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=247, type=symmetric_quantize]; -"248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" [id=248, type=conv2d]; -"249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=249, type=batch_norm]; -"250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/relu__0" [id=250, type=relu_]; -"251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=251, type=symmetric_quantize]; -"252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=252, type=symmetric_quantize]; -"253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" [id=253, type=conv2d]; -"254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=254, type=batch_norm]; -"255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/relu__0" [id=255, type=relu_]; -"256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=256, type=symmetric_quantize]; -"257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=257, type=symmetric_quantize]; -"258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=258, type=conv2d]; -"259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=259, type=batch_norm]; -"260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=260, type=relu_]; -"261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=261, type=symmetric_quantize]; -"262 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=262, type=symmetric_quantize]; -"263 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=263, type=conv2d]; -"264 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=264, type=batch_norm]; -"265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=265, type=relu_]; -"266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=266, type=symmetric_quantize]; -"267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=267, type=symmetric_quantize]; -"268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=268, type=conv2d]; -"269 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=269, type=batch_norm]; -"270 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=270, type=relu_]; -"271 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=271, type=symmetric_quantize]; -"272 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=272, type=symmetric_quantize]; -"273 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" [id=273, type=conv2d]; -"274 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=274, type=batch_norm]; -"275 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=275, type=relu_]; -"276 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=276, type=symmetric_quantize]; -"277 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=277, type=symmetric_quantize]; -"278 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" [id=278, type=conv2d]; -"279 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=279, type=batch_norm]; -"280 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=280, type=relu_]; -"281 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=281, type=symmetric_quantize]; -"282 Inception3/InceptionC[Mixed_6c]/avg_pool2d_0" [id=282, type=avg_pool2d]; -"283 Inception3/InceptionC[Mixed_6c]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; -"284 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=284, type=symmetric_quantize]; -"285 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=285, type=conv2d]; -"286 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=286, type=batch_norm]; -"287 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/relu__0" [id=287, type=relu_]; -"288 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=288, type=symmetric_quantize]; -"289 Inception3/InceptionC[Mixed_6c]/cat_0" [id=289, type=cat]; -"290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=290, type=symmetric_quantize]; -"291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=291, type=conv2d]; -"292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=292, type=batch_norm]; -"293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/relu__0" [id=293, type=relu_]; -"294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=294, type=symmetric_quantize]; -"295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=295, type=symmetric_quantize]; -"296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" [id=296, type=conv2d]; -"297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=297, type=batch_norm]; -"298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/relu__0" [id=298, type=relu_]; -"299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=299, type=symmetric_quantize]; -"300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=300, type=symmetric_quantize]; -"301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" [id=301, type=conv2d]; -"302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=302, type=batch_norm]; -"303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/relu__0" [id=303, type=relu_]; -"304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=304, type=symmetric_quantize]; -"305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=305, type=symmetric_quantize]; -"306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" [id=306, type=conv2d]; -"307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=307, type=batch_norm]; -"308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/relu__0" [id=308, type=relu_]; -"309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=309, type=symmetric_quantize]; -"310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=310, type=symmetric_quantize]; -"311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=311, type=conv2d]; -"312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=312, type=batch_norm]; -"313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=313, type=relu_]; -"314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=314, type=symmetric_quantize]; -"315 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=315, type=symmetric_quantize]; -"316 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=316, type=conv2d]; -"317 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=317, type=batch_norm]; -"318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=318, type=relu_]; -"319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=319, type=symmetric_quantize]; -"320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=320, type=symmetric_quantize]; -"321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=321, type=conv2d]; -"322 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=322, type=batch_norm]; -"323 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=323, type=relu_]; -"324 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=324, type=symmetric_quantize]; -"325 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=325, type=symmetric_quantize]; -"326 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" [id=326, type=conv2d]; -"327 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=327, type=batch_norm]; -"328 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=328, type=relu_]; -"329 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; -"330 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=330, type=symmetric_quantize]; -"331 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" [id=331, type=conv2d]; -"332 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=332, type=batch_norm]; -"333 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=333, type=relu_]; -"334 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=334, type=symmetric_quantize]; -"335 Inception3/InceptionC[Mixed_6d]/avg_pool2d_0" [id=335, type=avg_pool2d]; -"336 Inception3/InceptionC[Mixed_6d]/SymmetricQuantizer/symmetric_quantize_0" [id=336, type=symmetric_quantize]; -"337 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=337, type=symmetric_quantize]; -"338 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=338, type=conv2d]; -"339 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=339, type=batch_norm]; -"340 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/relu__0" [id=340, type=relu_]; -"341 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=341, type=symmetric_quantize]; -"342 Inception3/InceptionC[Mixed_6d]/cat_0" [id=342, type=cat]; -"343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=343, type=symmetric_quantize]; -"344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=344, type=conv2d]; -"345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=345, type=batch_norm]; -"346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/relu__0" [id=346, type=relu_]; -"347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; -"348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=348, type=symmetric_quantize]; -"349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" [id=349, type=conv2d]; -"350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=350, type=batch_norm]; -"351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/relu__0" [id=351, type=relu_]; -"352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=352, type=symmetric_quantize]; -"353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=353, type=symmetric_quantize]; -"354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" [id=354, type=conv2d]; -"355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=355, type=batch_norm]; -"356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/relu__0" [id=356, type=relu_]; -"357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=357, type=symmetric_quantize]; -"358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=358, type=symmetric_quantize]; -"359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" [id=359, type=conv2d]; -"360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=360, type=batch_norm]; -"361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/relu__0" [id=361, type=relu_]; -"362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=362, type=symmetric_quantize]; -"363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=363, type=symmetric_quantize]; -"364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=364, type=conv2d]; -"365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=365, type=batch_norm]; -"366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=366, type=relu_]; -"367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=367, type=symmetric_quantize]; -"368 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=368, type=symmetric_quantize]; -"369 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=369, type=conv2d]; -"370 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=370, type=batch_norm]; -"371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=371, type=relu_]; -"372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=372, type=symmetric_quantize]; -"373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=373, type=symmetric_quantize]; -"374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" [id=374, type=conv2d]; -"375 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=375, type=batch_norm]; -"376 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=376, type=relu_]; -"377 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=377, type=symmetric_quantize]; -"378 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=378, type=symmetric_quantize]; -"379 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" [id=379, type=conv2d]; -"380 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=380, type=batch_norm]; -"381 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=381, type=relu_]; -"382 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=382, type=symmetric_quantize]; -"383 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=383, type=symmetric_quantize]; -"384 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" [id=384, type=conv2d]; -"385 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=385, type=batch_norm]; -"386 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=386, type=relu_]; -"387 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=387, type=symmetric_quantize]; -"388 Inception3/InceptionC[Mixed_6e]/avg_pool2d_0" [id=388, type=avg_pool2d]; -"389 Inception3/InceptionC[Mixed_6e]/SymmetricQuantizer/symmetric_quantize_0" [id=389, type=symmetric_quantize]; -"390 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=390, type=symmetric_quantize]; -"391 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=391, type=conv2d]; -"392 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=392, type=batch_norm]; -"393 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/relu__0" [id=393, type=relu_]; -"394 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=394, type=symmetric_quantize]; -"395 Inception3/InceptionC[Mixed_6e]/cat_0" [id=395, type=cat]; -"396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=396, type=symmetric_quantize]; -"397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0" [id=397, type=conv2d]; -"398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=398, type=batch_norm]; -"399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/relu__0" [id=399, type=relu_]; -"400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=400, type=symmetric_quantize]; -"401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=401, type=symmetric_quantize]; -"402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d_0" [id=402, type=conv2d]; -"403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=403, type=batch_norm]; -"404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/relu__0" [id=404, type=relu_]; -"405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize_0" [id=405, type=symmetric_quantize]; -"406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=406, type=symmetric_quantize]; -"407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d_0" [id=407, type=conv2d]; -"408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=408, type=batch_norm]; -"409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/relu__0" [id=409, type=relu_]; -"410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=410, type=symmetric_quantize]; -"411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=411, type=symmetric_quantize]; -"412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d_0" [id=412, type=conv2d]; -"413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=413, type=batch_norm]; -"414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/relu__0" [id=414, type=relu_]; -"415 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/SymmetricQuantizer/symmetric_quantize_0" [id=415, type=symmetric_quantize]; -"416 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=416, type=symmetric_quantize]; -"417 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d_0" [id=417, type=conv2d]; -"418 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=418, type=batch_norm]; -"419 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/relu__0" [id=419, type=relu_]; -"420 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/SymmetricQuantizer/symmetric_quantize_0" [id=420, type=symmetric_quantize]; -"421 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=421, type=symmetric_quantize]; -"422 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d_0" [id=422, type=conv2d]; -"423 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=423, type=batch_norm]; -"424 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/relu__0" [id=424, type=relu_]; -"425 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize_0" [id=425, type=symmetric_quantize]; -"426 Inception3/InceptionD[Mixed_7a]/max_pool2d_0" [id=426, type=max_pool2d]; -"427 Inception3/InceptionD[Mixed_7a]/cat_0" [id=427, type=cat]; -"428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=428, type=symmetric_quantize]; -"429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=429, type=conv2d]; -"430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=430, type=batch_norm]; -"431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/relu__0" [id=431, type=relu_]; -"432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=432, type=symmetric_quantize]; -"433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=433, type=symmetric_quantize]; -"434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0" [id=434, type=conv2d]; -"435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=435, type=batch_norm]; -"436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/relu__0" [id=436, type=relu_]; -"437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=437, type=symmetric_quantize]; -"438 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=438, type=symmetric_quantize]; -"439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0" [id=439, type=conv2d]; -"440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=440, type=batch_norm]; -"441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/relu__0" [id=441, type=relu_]; -"442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" [id=442, type=symmetric_quantize]; -"443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=443, type=symmetric_quantize]; -"444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0" [id=444, type=conv2d]; -"445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=445, type=batch_norm]; -"446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/relu__0" [id=446, type=relu_]; -"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" [id=447, type=symmetric_quantize]; -"448 Inception3/InceptionE[Mixed_7b]/cat_0" [id=448, type=cat]; -"449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=449, type=symmetric_quantize]; -"450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=450, type=conv2d]; -"451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=451, type=batch_norm]; -"452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=452, type=relu_]; -"453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=453, type=symmetric_quantize]; -"454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=454, type=symmetric_quantize]; -"455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=455, type=conv2d]; -"456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=456, type=batch_norm]; -"457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=457, type=relu_]; -"458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=458, type=symmetric_quantize]; -"459 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=459, type=symmetric_quantize]; -"460 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0" [id=460, type=conv2d]; -"461 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=461, type=batch_norm]; -"462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/relu__0" [id=462, type=relu_]; -"463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" [id=463, type=symmetric_quantize]; -"464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=464, type=symmetric_quantize]; -"465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0" [id=465, type=conv2d]; -"466 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=466, type=batch_norm]; -"467 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/relu__0" [id=467, type=relu_]; -"468 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" [id=468, type=symmetric_quantize]; -"469 Inception3/InceptionE[Mixed_7b]/cat_1" [id=469, type=cat]; -"470 Inception3/InceptionE[Mixed_7b]/avg_pool2d_0" [id=470, type=avg_pool2d]; -"471 Inception3/InceptionE[Mixed_7b]/SymmetricQuantizer/symmetric_quantize_0" [id=471, type=symmetric_quantize]; -"472 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=472, type=symmetric_quantize]; -"473 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=473, type=conv2d]; -"474 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=474, type=batch_norm]; -"475 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/relu__0" [id=475, type=relu_]; -"476 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=476, type=symmetric_quantize]; -"477 Inception3/InceptionE[Mixed_7b]/cat_2" [id=477, type=cat]; -"478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=478, type=symmetric_quantize]; -"479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" [id=479, type=conv2d]; -"480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=480, type=batch_norm]; -"481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/relu__0" [id=481, type=relu_]; -"482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=482, type=symmetric_quantize]; -"483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=483, type=symmetric_quantize]; -"484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0" [id=484, type=conv2d]; -"485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=485, type=batch_norm]; -"486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/relu__0" [id=486, type=relu_]; -"487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=487, type=symmetric_quantize]; -"488 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=488, type=symmetric_quantize]; -"489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0" [id=489, type=conv2d]; -"490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=490, type=batch_norm]; -"491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/relu__0" [id=491, type=relu_]; -"492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" [id=492, type=symmetric_quantize]; -"493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=493, type=symmetric_quantize]; -"494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0" [id=494, type=conv2d]; -"495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=495, type=batch_norm]; -"496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/relu__0" [id=496, type=relu_]; -"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" [id=497, type=symmetric_quantize]; -"498 Inception3/InceptionE[Mixed_7c]/cat_0" [id=498, type=cat]; -"499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=499, type=symmetric_quantize]; -"500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" [id=500, type=conv2d]; -"501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=501, type=batch_norm]; -"502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=502, type=relu_]; -"503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=503, type=symmetric_quantize]; -"504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=504, type=symmetric_quantize]; -"505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" [id=505, type=conv2d]; -"506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=506, type=batch_norm]; -"507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=507, type=relu_]; -"508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=508, type=symmetric_quantize]; -"509 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=509, type=symmetric_quantize]; -"510 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0" [id=510, type=conv2d]; -"511 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=511, type=batch_norm]; -"512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/relu__0" [id=512, type=relu_]; -"513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" [id=513, type=symmetric_quantize]; -"514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=514, type=symmetric_quantize]; -"515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0" [id=515, type=conv2d]; -"516 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=516, type=batch_norm]; -"517 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/relu__0" [id=517, type=relu_]; -"518 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" [id=518, type=symmetric_quantize]; -"519 Inception3/InceptionE[Mixed_7c]/cat_1" [id=519, type=cat]; -"520 Inception3/InceptionE[Mixed_7c]/avg_pool2d_0" [id=520, type=avg_pool2d]; -"521 Inception3/InceptionE[Mixed_7c]/SymmetricQuantizer/symmetric_quantize_0" [id=521, type=symmetric_quantize]; -"522 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=522, type=symmetric_quantize]; -"523 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" [id=523, type=conv2d]; -"524 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=524, type=batch_norm]; -"525 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/relu__0" [id=525, type=relu_]; -"526 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=526, type=symmetric_quantize]; -"527 Inception3/InceptionE[Mixed_7c]/cat_2" [id=527, type=cat]; -"528 Inception3/adaptive_avg_pool2d_0" [id=528, type=adaptive_avg_pool2d]; -"529 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=529, type=symmetric_quantize]; -"530 Inception3/dropout_0" [id=530, type=dropout]; -"531 Inception3/view_0" [id=531, type=view]; -"532 Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=532, type=symmetric_quantize]; -"533 Inception3/NNCFLinear[fc]/linear_0" [id=533, type=linear]; -"534 /nncf_model_output_0" [id=534, type=nncf_model_output]; +"21 Conv2d_1a_3x3.conv.weight" [id=21, type=nncf_model_const]; +"22 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/conv2d_0" [id=23, type=conv2d]; +"24 Conv2d_1a_3x3.bn.weight" [id=24, type=nncf_model_const]; +"25 Conv2d_1a_3x3.bn.bias" [id=25, type=nncf_model_const]; +"26 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm_0" [id=26, type=batch_norm]; +"27 Inception3/BasicConv2d[Conv2d_1a_3x3]/relu__0" [id=27, type=relu_]; +"28 Inception3/BasicConv2d[Conv2d_1a_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; +"29 Conv2d_2a_3x3.conv.weight" [id=29, type=nncf_model_const]; +"30 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d_0" [id=31, type=conv2d]; +"32 Conv2d_2a_3x3.bn.weight" [id=32, type=nncf_model_const]; +"33 Conv2d_2a_3x3.bn.bias" [id=33, type=nncf_model_const]; +"34 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm_0" [id=34, type=batch_norm]; +"35 Inception3/BasicConv2d[Conv2d_2a_3x3]/relu__0" [id=35, type=relu_]; +"36 Inception3/BasicConv2d[Conv2d_2a_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; +"37 Conv2d_2b_3x3.conv.weight" [id=37, type=nncf_model_const]; +"38 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/conv2d_0" [id=39, type=conv2d]; +"40 Conv2d_2b_3x3.bn.weight" [id=40, type=nncf_model_const]; +"41 Conv2d_2b_3x3.bn.bias" [id=41, type=nncf_model_const]; +"42 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm_0" [id=42, type=batch_norm]; +"43 Inception3/BasicConv2d[Conv2d_2b_3x3]/relu__0" [id=43, type=relu_]; +"44 Inception3/BasicConv2d[Conv2d_2b_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; +"45 Inception3/max_pool2d_0" [id=45, type=max_pool2d]; +"46 Conv2d_3b_1x1.conv.weight" [id=46, type=nncf_model_const]; +"47 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=47, type=symmetric_quantize]; +"48 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/conv2d_0" [id=48, type=conv2d]; +"49 Conv2d_3b_1x1.bn.weight" [id=49, type=nncf_model_const]; +"50 Conv2d_3b_1x1.bn.bias" [id=50, type=nncf_model_const]; +"51 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm_0" [id=51, type=batch_norm]; +"52 Inception3/BasicConv2d[Conv2d_3b_1x1]/relu__0" [id=52, type=relu_]; +"53 Inception3/BasicConv2d[Conv2d_3b_1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=53, type=symmetric_quantize]; +"54 Conv2d_4a_3x3.conv.weight" [id=54, type=nncf_model_const]; +"55 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; +"56 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/conv2d_0" [id=56, type=conv2d]; +"57 Conv2d_4a_3x3.bn.weight" [id=57, type=nncf_model_const]; +"58 Conv2d_4a_3x3.bn.bias" [id=58, type=nncf_model_const]; +"59 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm_0" [id=59, type=batch_norm]; +"60 Inception3/BasicConv2d[Conv2d_4a_3x3]/relu__0" [id=60, type=relu_]; +"61 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 Inception3/max_pool2d_1" [id=62, type=max_pool2d]; +"63 Mixed_5b.branch1x1.conv.weight" [id=63, type=nncf_model_const]; +"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; +"65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=65, type=conv2d]; +"66 Mixed_5b.branch1x1.bn.weight" [id=66, type=nncf_model_const]; +"67 Mixed_5b.branch1x1.bn.bias" [id=67, type=nncf_model_const]; +"68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=68, type=batch_norm]; +"69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/relu__0" [id=69, type=relu_]; +"70 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 Mixed_5b.branch5x5_1.conv.weight" [id=71, type=nncf_model_const]; +"72 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=72, type=symmetric_quantize]; +"73 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0" [id=73, type=conv2d]; +"74 Mixed_5b.branch5x5_1.bn.weight" [id=74, type=nncf_model_const]; +"75 Mixed_5b.branch5x5_1.bn.bias" [id=75, type=nncf_model_const]; +"76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0" [id=76, type=batch_norm]; +"77 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/relu__0" [id=77, type=relu_]; +"78 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" [id=78, type=symmetric_quantize]; +"79 Mixed_5b.branch5x5_2.conv.weight" [id=79, type=nncf_model_const]; +"80 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0" [id=81, type=conv2d]; +"82 Mixed_5b.branch5x5_2.bn.weight" [id=82, type=nncf_model_const]; +"83 Mixed_5b.branch5x5_2.bn.bias" [id=83, type=nncf_model_const]; +"84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0" [id=84, type=batch_norm]; +"85 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/relu__0" [id=85, type=relu_]; +"86 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 Mixed_5b.branch3x3dbl_1.conv.weight" [id=87, type=nncf_model_const]; +"88 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; +"89 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" [id=89, type=conv2d]; +"90 Mixed_5b.branch3x3dbl_1.bn.weight" [id=90, type=nncf_model_const]; +"91 Mixed_5b.branch3x3dbl_1.bn.bias" [id=91, type=nncf_model_const]; +"92 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=92, type=batch_norm]; +"93 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=93, type=relu_]; +"94 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 Mixed_5b.branch3x3dbl_2.conv.weight" [id=95, type=nncf_model_const]; +"96 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; +"97 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" [id=97, type=conv2d]; +"98 Mixed_5b.branch3x3dbl_2.bn.weight" [id=98, type=nncf_model_const]; +"99 Mixed_5b.branch3x3dbl_2.bn.bias" [id=99, type=nncf_model_const]; +"100 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=100, type=batch_norm]; +"101 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=101, type=relu_]; +"102 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 Mixed_5b.branch3x3dbl_3.conv.weight" [id=103, type=nncf_model_const]; +"104 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=104, type=symmetric_quantize]; +"105 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" [id=105, type=conv2d]; +"106 Mixed_5b.branch3x3dbl_3.bn.weight" [id=106, type=nncf_model_const]; +"107 Mixed_5b.branch3x3dbl_3.bn.bias" [id=107, type=nncf_model_const]; +"108 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=108, type=batch_norm]; +"109 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=109, type=relu_]; +"110 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 Inception3/InceptionA[Mixed_5b]/avg_pool2d_0" [id=111, type=avg_pool2d]; +"112 Inception3/InceptionA[Mixed_5b]/SymmetricQuantizer/symmetric_quantize_0" [id=112, type=symmetric_quantize]; +"113 Mixed_5b.branch_pool.conv.weight" [id=113, type=nncf_model_const]; +"114 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=115, type=conv2d]; +"116 Mixed_5b.branch_pool.bn.weight" [id=116, type=nncf_model_const]; +"117 Mixed_5b.branch_pool.bn.bias" [id=117, type=nncf_model_const]; +"118 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=118, type=batch_norm]; +"119 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/relu__0" [id=119, type=relu_]; +"120 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 Inception3/InceptionA[Mixed_5b]/cat_0" [id=121, type=cat]; +"122 Mixed_5c.branch1x1.conv.weight" [id=122, type=nncf_model_const]; +"123 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=124, type=conv2d]; +"125 Mixed_5c.branch1x1.bn.weight" [id=125, type=nncf_model_const]; +"126 Mixed_5c.branch1x1.bn.bias" [id=126, type=nncf_model_const]; +"127 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=127, type=batch_norm]; +"128 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/relu__0" [id=128, type=relu_]; +"129 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 Mixed_5c.branch5x5_1.conv.weight" [id=130, type=nncf_model_const]; +"131 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; +"132 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0" [id=132, type=conv2d]; +"133 Mixed_5c.branch5x5_1.bn.weight" [id=133, type=nncf_model_const]; +"134 Mixed_5c.branch5x5_1.bn.bias" [id=134, type=nncf_model_const]; +"135 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0" [id=135, type=batch_norm]; +"136 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/relu__0" [id=136, type=relu_]; +"137 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" [id=137, type=symmetric_quantize]; +"138 Mixed_5c.branch5x5_2.conv.weight" [id=138, type=nncf_model_const]; +"139 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0" [id=140, type=conv2d]; +"141 Mixed_5c.branch5x5_2.bn.weight" [id=141, type=nncf_model_const]; +"142 Mixed_5c.branch5x5_2.bn.bias" [id=142, type=nncf_model_const]; +"143 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0" [id=143, type=batch_norm]; +"144 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/relu__0" [id=144, type=relu_]; +"145 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 Mixed_5c.branch3x3dbl_1.conv.weight" [id=146, type=nncf_model_const]; +"147 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" [id=148, type=conv2d]; +"149 Mixed_5c.branch3x3dbl_1.bn.weight" [id=149, type=nncf_model_const]; +"150 Mixed_5c.branch3x3dbl_1.bn.bias" [id=150, type=nncf_model_const]; +"151 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=151, type=batch_norm]; +"152 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=152, type=relu_]; +"153 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=153, type=symmetric_quantize]; +"154 Mixed_5c.branch3x3dbl_2.conv.weight" [id=154, type=nncf_model_const]; +"155 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; +"156 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" [id=156, type=conv2d]; +"157 Mixed_5c.branch3x3dbl_2.bn.weight" [id=157, type=nncf_model_const]; +"158 Mixed_5c.branch3x3dbl_2.bn.bias" [id=158, type=nncf_model_const]; +"159 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=159, type=batch_norm]; +"160 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=160, type=relu_]; +"161 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 Mixed_5c.branch3x3dbl_3.conv.weight" [id=162, type=nncf_model_const]; +"163 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=163, type=symmetric_quantize]; +"164 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" [id=164, type=conv2d]; +"165 Mixed_5c.branch3x3dbl_3.bn.weight" [id=165, type=nncf_model_const]; +"166 Mixed_5c.branch3x3dbl_3.bn.bias" [id=166, type=nncf_model_const]; +"167 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=167, type=batch_norm]; +"168 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=168, type=relu_]; +"169 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=169, type=symmetric_quantize]; +"170 Inception3/InceptionA[Mixed_5c]/avg_pool2d_0" [id=170, type=avg_pool2d]; +"171 Inception3/InceptionA[Mixed_5c]/SymmetricQuantizer/symmetric_quantize_0" [id=171, type=symmetric_quantize]; +"172 Mixed_5c.branch_pool.conv.weight" [id=172, type=nncf_model_const]; +"173 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=173, type=symmetric_quantize]; +"174 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=174, type=conv2d]; +"175 Mixed_5c.branch_pool.bn.weight" [id=175, type=nncf_model_const]; +"176 Mixed_5c.branch_pool.bn.bias" [id=176, type=nncf_model_const]; +"177 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=177, type=batch_norm]; +"178 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/relu__0" [id=178, type=relu_]; +"179 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=179, type=symmetric_quantize]; +"180 Inception3/InceptionA[Mixed_5c]/cat_0" [id=180, type=cat]; +"181 Mixed_5d.branch1x1.conv.weight" [id=181, type=nncf_model_const]; +"182 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=183, type=conv2d]; +"184 Mixed_5d.branch1x1.bn.weight" [id=184, type=nncf_model_const]; +"185 Mixed_5d.branch1x1.bn.bias" [id=185, type=nncf_model_const]; +"186 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=186, type=batch_norm]; +"187 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/relu__0" [id=187, type=relu_]; +"188 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; +"189 Mixed_5d.branch5x5_1.conv.weight" [id=189, type=nncf_model_const]; +"190 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=190, type=symmetric_quantize]; +"191 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0" [id=191, type=conv2d]; +"192 Mixed_5d.branch5x5_1.bn.weight" [id=192, type=nncf_model_const]; +"193 Mixed_5d.branch5x5_1.bn.bias" [id=193, type=nncf_model_const]; +"194 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0" [id=194, type=batch_norm]; +"195 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/relu__0" [id=195, type=relu_]; +"196 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" [id=196, type=symmetric_quantize]; +"197 Mixed_5d.branch5x5_2.conv.weight" [id=197, type=nncf_model_const]; +"198 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; +"199 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0" [id=199, type=conv2d]; +"200 Mixed_5d.branch5x5_2.bn.weight" [id=200, type=nncf_model_const]; +"201 Mixed_5d.branch5x5_2.bn.bias" [id=201, type=nncf_model_const]; +"202 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0" [id=202, type=batch_norm]; +"203 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/relu__0" [id=203, type=relu_]; +"204 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" [id=204, type=symmetric_quantize]; +"205 Mixed_5d.branch3x3dbl_1.conv.weight" [id=205, type=nncf_model_const]; +"206 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=206, type=symmetric_quantize]; +"207 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" [id=207, type=conv2d]; +"208 Mixed_5d.branch3x3dbl_1.bn.weight" [id=208, type=nncf_model_const]; +"209 Mixed_5d.branch3x3dbl_1.bn.bias" [id=209, type=nncf_model_const]; +"210 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=210, type=batch_norm]; +"211 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=211, type=relu_]; +"212 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=212, type=symmetric_quantize]; +"213 Mixed_5d.branch3x3dbl_2.conv.weight" [id=213, type=nncf_model_const]; +"214 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=214, type=symmetric_quantize]; +"215 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" [id=215, type=conv2d]; +"216 Mixed_5d.branch3x3dbl_2.bn.weight" [id=216, type=nncf_model_const]; +"217 Mixed_5d.branch3x3dbl_2.bn.bias" [id=217, type=nncf_model_const]; +"218 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=218, type=batch_norm]; +"219 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=219, type=relu_]; +"220 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=220, type=symmetric_quantize]; +"221 Mixed_5d.branch3x3dbl_3.conv.weight" [id=221, type=nncf_model_const]; +"222 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=222, type=symmetric_quantize]; +"223 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" [id=223, type=conv2d]; +"224 Mixed_5d.branch3x3dbl_3.bn.weight" [id=224, type=nncf_model_const]; +"225 Mixed_5d.branch3x3dbl_3.bn.bias" [id=225, type=nncf_model_const]; +"226 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=226, type=batch_norm]; +"227 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=227, type=relu_]; +"228 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 Inception3/InceptionA[Mixed_5d]/avg_pool2d_0" [id=229, type=avg_pool2d]; +"230 Inception3/InceptionA[Mixed_5d]/SymmetricQuantizer/symmetric_quantize_0" [id=230, type=symmetric_quantize]; +"231 Mixed_5d.branch_pool.conv.weight" [id=231, type=nncf_model_const]; +"232 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=232, type=symmetric_quantize]; +"233 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=233, type=conv2d]; +"234 Mixed_5d.branch_pool.bn.weight" [id=234, type=nncf_model_const]; +"235 Mixed_5d.branch_pool.bn.bias" [id=235, type=nncf_model_const]; +"236 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=236, type=batch_norm]; +"237 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/relu__0" [id=237, type=relu_]; +"238 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=238, type=symmetric_quantize]; +"239 Inception3/InceptionA[Mixed_5d]/cat_0" [id=239, type=cat]; +"240 Mixed_6a.branch3x3.conv.weight" [id=240, type=nncf_model_const]; +"241 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/conv2d_0" [id=242, type=conv2d]; +"243 Mixed_6a.branch3x3.bn.weight" [id=243, type=nncf_model_const]; +"244 Mixed_6a.branch3x3.bn.bias" [id=244, type=nncf_model_const]; +"245 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm_0" [id=245, type=batch_norm]; +"246 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/relu__0" [id=246, type=relu_]; +"247 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=247, type=symmetric_quantize]; +"248 Mixed_6a.branch3x3dbl_1.conv.weight" [id=248, type=nncf_model_const]; +"249 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=249, type=symmetric_quantize]; +"250 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" [id=250, type=conv2d]; +"251 Mixed_6a.branch3x3dbl_1.bn.weight" [id=251, type=nncf_model_const]; +"252 Mixed_6a.branch3x3dbl_1.bn.bias" [id=252, type=nncf_model_const]; +"253 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=253, type=batch_norm]; +"254 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=254, type=relu_]; +"255 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 Mixed_6a.branch3x3dbl_2.conv.weight" [id=256, type=nncf_model_const]; +"257 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=257, type=symmetric_quantize]; +"258 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" [id=258, type=conv2d]; +"259 Mixed_6a.branch3x3dbl_2.bn.weight" [id=259, type=nncf_model_const]; +"260 Mixed_6a.branch3x3dbl_2.bn.bias" [id=260, type=nncf_model_const]; +"261 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=261, type=batch_norm]; +"262 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=262, type=relu_]; +"263 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=263, type=symmetric_quantize]; +"264 Mixed_6a.branch3x3dbl_3.conv.weight" [id=264, type=nncf_model_const]; +"265 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=265, type=symmetric_quantize]; +"266 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" [id=266, type=conv2d]; +"267 Mixed_6a.branch3x3dbl_3.bn.weight" [id=267, type=nncf_model_const]; +"268 Mixed_6a.branch3x3dbl_3.bn.bias" [id=268, type=nncf_model_const]; +"269 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=269, type=batch_norm]; +"270 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/relu__0" [id=270, type=relu_]; +"271 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=271, type=symmetric_quantize]; +"272 Inception3/InceptionB[Mixed_6a]/max_pool2d_0" [id=272, type=max_pool2d]; +"273 Inception3/InceptionB[Mixed_6a]/cat_0" [id=273, type=cat]; +"274 Mixed_6b.branch1x1.conv.weight" [id=274, type=nncf_model_const]; +"275 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; +"276 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=276, type=conv2d]; +"277 Mixed_6b.branch1x1.bn.weight" [id=277, type=nncf_model_const]; +"278 Mixed_6b.branch1x1.bn.bias" [id=278, type=nncf_model_const]; +"279 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=279, type=batch_norm]; +"280 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/relu__0" [id=280, type=relu_]; +"281 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=281, type=symmetric_quantize]; +"282 Mixed_6b.branch7x7_1.conv.weight" [id=282, type=nncf_model_const]; +"283 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" [id=284, type=conv2d]; +"285 Mixed_6b.branch7x7_1.bn.weight" [id=285, type=nncf_model_const]; +"286 Mixed_6b.branch7x7_1.bn.bias" [id=286, type=nncf_model_const]; +"287 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" [id=287, type=batch_norm]; +"288 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/relu__0" [id=288, type=relu_]; +"289 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 Mixed_6b.branch7x7_2.conv.weight" [id=290, type=nncf_model_const]; +"291 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" [id=292, type=conv2d]; +"293 Mixed_6b.branch7x7_2.bn.weight" [id=293, type=nncf_model_const]; +"294 Mixed_6b.branch7x7_2.bn.bias" [id=294, type=nncf_model_const]; +"295 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" [id=295, type=batch_norm]; +"296 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/relu__0" [id=296, type=relu_]; +"297 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=297, type=symmetric_quantize]; +"298 Mixed_6b.branch7x7_3.conv.weight" [id=298, type=nncf_model_const]; +"299 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=299, type=symmetric_quantize]; +"300 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" [id=300, type=conv2d]; +"301 Mixed_6b.branch7x7_3.bn.weight" [id=301, type=nncf_model_const]; +"302 Mixed_6b.branch7x7_3.bn.bias" [id=302, type=nncf_model_const]; +"303 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" [id=303, type=batch_norm]; +"304 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/relu__0" [id=304, type=relu_]; +"305 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=305, type=symmetric_quantize]; +"306 Mixed_6b.branch7x7dbl_1.conv.weight" [id=306, type=nncf_model_const]; +"307 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=307, type=symmetric_quantize]; +"308 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" [id=308, type=conv2d]; +"309 Mixed_6b.branch7x7dbl_1.bn.weight" [id=309, type=nncf_model_const]; +"310 Mixed_6b.branch7x7dbl_1.bn.bias" [id=310, type=nncf_model_const]; +"311 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=311, type=batch_norm]; +"312 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=312, type=relu_]; +"313 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=313, type=symmetric_quantize]; +"314 Mixed_6b.branch7x7dbl_2.conv.weight" [id=314, type=nncf_model_const]; +"315 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=315, type=symmetric_quantize]; +"316 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" [id=316, type=conv2d]; +"317 Mixed_6b.branch7x7dbl_2.bn.weight" [id=317, type=nncf_model_const]; +"318 Mixed_6b.branch7x7dbl_2.bn.bias" [id=318, type=nncf_model_const]; +"319 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=319, type=batch_norm]; +"320 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=320, type=relu_]; +"321 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=321, type=symmetric_quantize]; +"322 Mixed_6b.branch7x7dbl_3.conv.weight" [id=322, type=nncf_model_const]; +"323 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=323, type=symmetric_quantize]; +"324 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" [id=324, type=conv2d]; +"325 Mixed_6b.branch7x7dbl_3.bn.weight" [id=325, type=nncf_model_const]; +"326 Mixed_6b.branch7x7dbl_3.bn.bias" [id=326, type=nncf_model_const]; +"327 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=327, type=batch_norm]; +"328 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=328, type=relu_]; +"329 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; +"330 Mixed_6b.branch7x7dbl_4.conv.weight" [id=330, type=nncf_model_const]; +"331 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=331, type=symmetric_quantize]; +"332 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" [id=332, type=conv2d]; +"333 Mixed_6b.branch7x7dbl_4.bn.weight" [id=333, type=nncf_model_const]; +"334 Mixed_6b.branch7x7dbl_4.bn.bias" [id=334, type=nncf_model_const]; +"335 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" [id=335, type=batch_norm]; +"336 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=336, type=relu_]; +"337 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 Mixed_6b.branch7x7dbl_5.conv.weight" [id=338, type=nncf_model_const]; +"339 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" [id=340, type=conv2d]; +"341 Mixed_6b.branch7x7dbl_5.bn.weight" [id=341, type=nncf_model_const]; +"342 Mixed_6b.branch7x7dbl_5.bn.bias" [id=342, type=nncf_model_const]; +"343 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" [id=343, type=batch_norm]; +"344 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=344, type=relu_]; +"345 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=345, type=symmetric_quantize]; +"346 Inception3/InceptionC[Mixed_6b]/avg_pool2d_0" [id=346, type=avg_pool2d]; +"347 Inception3/InceptionC[Mixed_6b]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; +"348 Mixed_6b.branch_pool.conv.weight" [id=348, type=nncf_model_const]; +"349 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=349, type=symmetric_quantize]; +"350 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=350, type=conv2d]; +"351 Mixed_6b.branch_pool.bn.weight" [id=351, type=nncf_model_const]; +"352 Mixed_6b.branch_pool.bn.bias" [id=352, type=nncf_model_const]; +"353 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=353, type=batch_norm]; +"354 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/relu__0" [id=354, type=relu_]; +"355 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=355, type=symmetric_quantize]; +"356 Inception3/InceptionC[Mixed_6b]/cat_0" [id=356, type=cat]; +"357 Mixed_6c.branch1x1.conv.weight" [id=357, type=nncf_model_const]; +"358 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=358, type=symmetric_quantize]; +"359 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=359, type=conv2d]; +"360 Mixed_6c.branch1x1.bn.weight" [id=360, type=nncf_model_const]; +"361 Mixed_6c.branch1x1.bn.bias" [id=361, type=nncf_model_const]; +"362 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=362, type=batch_norm]; +"363 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/relu__0" [id=363, type=relu_]; +"364 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=364, type=symmetric_quantize]; +"365 Mixed_6c.branch7x7_1.conv.weight" [id=365, type=nncf_model_const]; +"366 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=366, type=symmetric_quantize]; +"367 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" [id=367, type=conv2d]; +"368 Mixed_6c.branch7x7_1.bn.weight" [id=368, type=nncf_model_const]; +"369 Mixed_6c.branch7x7_1.bn.bias" [id=369, type=nncf_model_const]; +"370 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" [id=370, type=batch_norm]; +"371 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/relu__0" [id=371, type=relu_]; +"372 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=372, type=symmetric_quantize]; +"373 Mixed_6c.branch7x7_2.conv.weight" [id=373, type=nncf_model_const]; +"374 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=374, type=symmetric_quantize]; +"375 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" [id=375, type=conv2d]; +"376 Mixed_6c.branch7x7_2.bn.weight" [id=376, type=nncf_model_const]; +"377 Mixed_6c.branch7x7_2.bn.bias" [id=377, type=nncf_model_const]; +"378 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" [id=378, type=batch_norm]; +"379 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/relu__0" [id=379, type=relu_]; +"380 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=380, type=symmetric_quantize]; +"381 Mixed_6c.branch7x7_3.conv.weight" [id=381, type=nncf_model_const]; +"382 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=382, type=symmetric_quantize]; +"383 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" [id=383, type=conv2d]; +"384 Mixed_6c.branch7x7_3.bn.weight" [id=384, type=nncf_model_const]; +"385 Mixed_6c.branch7x7_3.bn.bias" [id=385, type=nncf_model_const]; +"386 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" [id=386, type=batch_norm]; +"387 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/relu__0" [id=387, type=relu_]; +"388 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=388, type=symmetric_quantize]; +"389 Mixed_6c.branch7x7dbl_1.conv.weight" [id=389, type=nncf_model_const]; +"390 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=390, type=symmetric_quantize]; +"391 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" [id=391, type=conv2d]; +"392 Mixed_6c.branch7x7dbl_1.bn.weight" [id=392, type=nncf_model_const]; +"393 Mixed_6c.branch7x7dbl_1.bn.bias" [id=393, type=nncf_model_const]; +"394 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=394, type=batch_norm]; +"395 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=395, type=relu_]; +"396 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=396, type=symmetric_quantize]; +"397 Mixed_6c.branch7x7dbl_2.conv.weight" [id=397, type=nncf_model_const]; +"398 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=398, type=symmetric_quantize]; +"399 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" [id=399, type=conv2d]; +"400 Mixed_6c.branch7x7dbl_2.bn.weight" [id=400, type=nncf_model_const]; +"401 Mixed_6c.branch7x7dbl_2.bn.bias" [id=401, type=nncf_model_const]; +"402 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=402, type=batch_norm]; +"403 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=403, type=relu_]; +"404 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=404, type=symmetric_quantize]; +"405 Mixed_6c.branch7x7dbl_3.conv.weight" [id=405, type=nncf_model_const]; +"406 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=406, type=symmetric_quantize]; +"407 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" [id=407, type=conv2d]; +"408 Mixed_6c.branch7x7dbl_3.bn.weight" [id=408, type=nncf_model_const]; +"409 Mixed_6c.branch7x7dbl_3.bn.bias" [id=409, type=nncf_model_const]; +"410 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=410, type=batch_norm]; +"411 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=411, type=relu_]; +"412 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=412, type=symmetric_quantize]; +"413 Mixed_6c.branch7x7dbl_4.conv.weight" [id=413, type=nncf_model_const]; +"414 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=414, type=symmetric_quantize]; +"415 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" [id=415, type=conv2d]; +"416 Mixed_6c.branch7x7dbl_4.bn.weight" [id=416, type=nncf_model_const]; +"417 Mixed_6c.branch7x7dbl_4.bn.bias" [id=417, type=nncf_model_const]; +"418 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" [id=418, type=batch_norm]; +"419 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=419, type=relu_]; +"420 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=420, type=symmetric_quantize]; +"421 Mixed_6c.branch7x7dbl_5.conv.weight" [id=421, type=nncf_model_const]; +"422 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=422, type=symmetric_quantize]; +"423 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" [id=423, type=conv2d]; +"424 Mixed_6c.branch7x7dbl_5.bn.weight" [id=424, type=nncf_model_const]; +"425 Mixed_6c.branch7x7dbl_5.bn.bias" [id=425, type=nncf_model_const]; +"426 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" [id=426, type=batch_norm]; +"427 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=427, type=relu_]; +"428 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=428, type=symmetric_quantize]; +"429 Inception3/InceptionC[Mixed_6c]/avg_pool2d_0" [id=429, type=avg_pool2d]; +"430 Inception3/InceptionC[Mixed_6c]/SymmetricQuantizer/symmetric_quantize_0" [id=430, type=symmetric_quantize]; +"431 Mixed_6c.branch_pool.conv.weight" [id=431, type=nncf_model_const]; +"432 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=432, type=symmetric_quantize]; +"433 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=433, type=conv2d]; +"434 Mixed_6c.branch_pool.bn.weight" [id=434, type=nncf_model_const]; +"435 Mixed_6c.branch_pool.bn.bias" [id=435, type=nncf_model_const]; +"436 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=436, type=batch_norm]; +"437 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/relu__0" [id=437, type=relu_]; +"438 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=438, type=symmetric_quantize]; +"439 Inception3/InceptionC[Mixed_6c]/cat_0" [id=439, type=cat]; +"440 Mixed_6d.branch1x1.conv.weight" [id=440, type=nncf_model_const]; +"441 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=441, type=symmetric_quantize]; +"442 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=442, type=conv2d]; +"443 Mixed_6d.branch1x1.bn.weight" [id=443, type=nncf_model_const]; +"444 Mixed_6d.branch1x1.bn.bias" [id=444, type=nncf_model_const]; +"445 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=445, type=batch_norm]; +"446 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/relu__0" [id=446, type=relu_]; +"447 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=447, type=symmetric_quantize]; +"448 Mixed_6d.branch7x7_1.conv.weight" [id=448, type=nncf_model_const]; +"449 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=449, type=symmetric_quantize]; +"450 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" [id=450, type=conv2d]; +"451 Mixed_6d.branch7x7_1.bn.weight" [id=451, type=nncf_model_const]; +"452 Mixed_6d.branch7x7_1.bn.bias" [id=452, type=nncf_model_const]; +"453 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" [id=453, type=batch_norm]; +"454 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/relu__0" [id=454, type=relu_]; +"455 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=455, type=symmetric_quantize]; +"456 Mixed_6d.branch7x7_2.conv.weight" [id=456, type=nncf_model_const]; +"457 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=457, type=symmetric_quantize]; +"458 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" [id=458, type=conv2d]; +"459 Mixed_6d.branch7x7_2.bn.weight" [id=459, type=nncf_model_const]; +"460 Mixed_6d.branch7x7_2.bn.bias" [id=460, type=nncf_model_const]; +"461 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" [id=461, type=batch_norm]; +"462 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/relu__0" [id=462, type=relu_]; +"463 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=463, type=symmetric_quantize]; +"464 Mixed_6d.branch7x7_3.conv.weight" [id=464, type=nncf_model_const]; +"465 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=465, type=symmetric_quantize]; +"466 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" [id=466, type=conv2d]; +"467 Mixed_6d.branch7x7_3.bn.weight" [id=467, type=nncf_model_const]; +"468 Mixed_6d.branch7x7_3.bn.bias" [id=468, type=nncf_model_const]; +"469 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" [id=469, type=batch_norm]; +"470 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/relu__0" [id=470, type=relu_]; +"471 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=471, type=symmetric_quantize]; +"472 Mixed_6d.branch7x7dbl_1.conv.weight" [id=472, type=nncf_model_const]; +"473 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=473, type=symmetric_quantize]; +"474 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" [id=474, type=conv2d]; +"475 Mixed_6d.branch7x7dbl_1.bn.weight" [id=475, type=nncf_model_const]; +"476 Mixed_6d.branch7x7dbl_1.bn.bias" [id=476, type=nncf_model_const]; +"477 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=477, type=batch_norm]; +"478 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=478, type=relu_]; +"479 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=479, type=symmetric_quantize]; +"480 Mixed_6d.branch7x7dbl_2.conv.weight" [id=480, type=nncf_model_const]; +"481 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=481, type=symmetric_quantize]; +"482 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" [id=482, type=conv2d]; +"483 Mixed_6d.branch7x7dbl_2.bn.weight" [id=483, type=nncf_model_const]; +"484 Mixed_6d.branch7x7dbl_2.bn.bias" [id=484, type=nncf_model_const]; +"485 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=485, type=batch_norm]; +"486 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=486, type=relu_]; +"487 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=487, type=symmetric_quantize]; +"488 Mixed_6d.branch7x7dbl_3.conv.weight" [id=488, type=nncf_model_const]; +"489 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=489, type=symmetric_quantize]; +"490 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" [id=490, type=conv2d]; +"491 Mixed_6d.branch7x7dbl_3.bn.weight" [id=491, type=nncf_model_const]; +"492 Mixed_6d.branch7x7dbl_3.bn.bias" [id=492, type=nncf_model_const]; +"493 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=493, type=batch_norm]; +"494 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=494, type=relu_]; +"495 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=495, type=symmetric_quantize]; +"496 Mixed_6d.branch7x7dbl_4.conv.weight" [id=496, type=nncf_model_const]; +"497 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=497, type=symmetric_quantize]; +"498 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" [id=498, type=conv2d]; +"499 Mixed_6d.branch7x7dbl_4.bn.weight" [id=499, type=nncf_model_const]; +"500 Mixed_6d.branch7x7dbl_4.bn.bias" [id=500, type=nncf_model_const]; +"501 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" [id=501, type=batch_norm]; +"502 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=502, type=relu_]; +"503 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=503, type=symmetric_quantize]; +"504 Mixed_6d.branch7x7dbl_5.conv.weight" [id=504, type=nncf_model_const]; +"505 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=505, type=symmetric_quantize]; +"506 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" [id=506, type=conv2d]; +"507 Mixed_6d.branch7x7dbl_5.bn.weight" [id=507, type=nncf_model_const]; +"508 Mixed_6d.branch7x7dbl_5.bn.bias" [id=508, type=nncf_model_const]; +"509 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" [id=509, type=batch_norm]; +"510 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=510, type=relu_]; +"511 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=511, type=symmetric_quantize]; +"512 Inception3/InceptionC[Mixed_6d]/avg_pool2d_0" [id=512, type=avg_pool2d]; +"513 Inception3/InceptionC[Mixed_6d]/SymmetricQuantizer/symmetric_quantize_0" [id=513, type=symmetric_quantize]; +"514 Mixed_6d.branch_pool.conv.weight" [id=514, type=nncf_model_const]; +"515 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=515, type=symmetric_quantize]; +"516 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=516, type=conv2d]; +"517 Mixed_6d.branch_pool.bn.weight" [id=517, type=nncf_model_const]; +"518 Mixed_6d.branch_pool.bn.bias" [id=518, type=nncf_model_const]; +"519 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=519, type=batch_norm]; +"520 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/relu__0" [id=520, type=relu_]; +"521 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=521, type=symmetric_quantize]; +"522 Inception3/InceptionC[Mixed_6d]/cat_0" [id=522, type=cat]; +"523 Mixed_6e.branch1x1.conv.weight" [id=523, type=nncf_model_const]; +"524 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=524, type=symmetric_quantize]; +"525 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=525, type=conv2d]; +"526 Mixed_6e.branch1x1.bn.weight" [id=526, type=nncf_model_const]; +"527 Mixed_6e.branch1x1.bn.bias" [id=527, type=nncf_model_const]; +"528 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=528, type=batch_norm]; +"529 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/relu__0" [id=529, type=relu_]; +"530 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=530, type=symmetric_quantize]; +"531 Mixed_6e.branch7x7_1.conv.weight" [id=531, type=nncf_model_const]; +"532 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=532, type=symmetric_quantize]; +"533 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" [id=533, type=conv2d]; +"534 Mixed_6e.branch7x7_1.bn.weight" [id=534, type=nncf_model_const]; +"535 Mixed_6e.branch7x7_1.bn.bias" [id=535, type=nncf_model_const]; +"536 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" [id=536, type=batch_norm]; +"537 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/relu__0" [id=537, type=relu_]; +"538 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" [id=538, type=symmetric_quantize]; +"539 Mixed_6e.branch7x7_2.conv.weight" [id=539, type=nncf_model_const]; +"540 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=540, type=symmetric_quantize]; +"541 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" [id=541, type=conv2d]; +"542 Mixed_6e.branch7x7_2.bn.weight" [id=542, type=nncf_model_const]; +"543 Mixed_6e.branch7x7_2.bn.bias" [id=543, type=nncf_model_const]; +"544 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" [id=544, type=batch_norm]; +"545 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/relu__0" [id=545, type=relu_]; +"546 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" [id=546, type=symmetric_quantize]; +"547 Mixed_6e.branch7x7_3.conv.weight" [id=547, type=nncf_model_const]; +"548 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=548, type=symmetric_quantize]; +"549 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" [id=549, type=conv2d]; +"550 Mixed_6e.branch7x7_3.bn.weight" [id=550, type=nncf_model_const]; +"551 Mixed_6e.branch7x7_3.bn.bias" [id=551, type=nncf_model_const]; +"552 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" [id=552, type=batch_norm]; +"553 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/relu__0" [id=553, type=relu_]; +"554 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" [id=554, type=symmetric_quantize]; +"555 Mixed_6e.branch7x7dbl_1.conv.weight" [id=555, type=nncf_model_const]; +"556 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=556, type=symmetric_quantize]; +"557 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" [id=557, type=conv2d]; +"558 Mixed_6e.branch7x7dbl_1.bn.weight" [id=558, type=nncf_model_const]; +"559 Mixed_6e.branch7x7dbl_1.bn.bias" [id=559, type=nncf_model_const]; +"560 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=560, type=batch_norm]; +"561 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/relu__0" [id=561, type=relu_]; +"562 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=562, type=symmetric_quantize]; +"563 Mixed_6e.branch7x7dbl_2.conv.weight" [id=563, type=nncf_model_const]; +"564 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=564, type=symmetric_quantize]; +"565 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" [id=565, type=conv2d]; +"566 Mixed_6e.branch7x7dbl_2.bn.weight" [id=566, type=nncf_model_const]; +"567 Mixed_6e.branch7x7dbl_2.bn.bias" [id=567, type=nncf_model_const]; +"568 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=568, type=batch_norm]; +"569 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/relu__0" [id=569, type=relu_]; +"570 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=570, type=symmetric_quantize]; +"571 Mixed_6e.branch7x7dbl_3.conv.weight" [id=571, type=nncf_model_const]; +"572 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=572, type=symmetric_quantize]; +"573 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" [id=573, type=conv2d]; +"574 Mixed_6e.branch7x7dbl_3.bn.weight" [id=574, type=nncf_model_const]; +"575 Mixed_6e.branch7x7dbl_3.bn.bias" [id=575, type=nncf_model_const]; +"576 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" [id=576, type=batch_norm]; +"577 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/relu__0" [id=577, type=relu_]; +"578 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" [id=578, type=symmetric_quantize]; +"579 Mixed_6e.branch7x7dbl_4.conv.weight" [id=579, type=nncf_model_const]; +"580 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=580, type=symmetric_quantize]; +"581 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" [id=581, type=conv2d]; +"582 Mixed_6e.branch7x7dbl_4.bn.weight" [id=582, type=nncf_model_const]; +"583 Mixed_6e.branch7x7dbl_4.bn.bias" [id=583, type=nncf_model_const]; +"584 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" [id=584, type=batch_norm]; +"585 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/relu__0" [id=585, type=relu_]; +"586 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" [id=586, type=symmetric_quantize]; +"587 Mixed_6e.branch7x7dbl_5.conv.weight" [id=587, type=nncf_model_const]; +"588 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=588, type=symmetric_quantize]; +"589 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" [id=589, type=conv2d]; +"590 Mixed_6e.branch7x7dbl_5.bn.weight" [id=590, type=nncf_model_const]; +"591 Mixed_6e.branch7x7dbl_5.bn.bias" [id=591, type=nncf_model_const]; +"592 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" [id=592, type=batch_norm]; +"593 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/relu__0" [id=593, type=relu_]; +"594 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" [id=594, type=symmetric_quantize]; +"595 Inception3/InceptionC[Mixed_6e]/avg_pool2d_0" [id=595, type=avg_pool2d]; +"596 Inception3/InceptionC[Mixed_6e]/SymmetricQuantizer/symmetric_quantize_0" [id=596, type=symmetric_quantize]; +"597 Mixed_6e.branch_pool.conv.weight" [id=597, type=nncf_model_const]; +"598 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=598, type=symmetric_quantize]; +"599 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=599, type=conv2d]; +"600 Mixed_6e.branch_pool.bn.weight" [id=600, type=nncf_model_const]; +"601 Mixed_6e.branch_pool.bn.bias" [id=601, type=nncf_model_const]; +"602 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=602, type=batch_norm]; +"603 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/relu__0" [id=603, type=relu_]; +"604 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=604, type=symmetric_quantize]; +"605 Inception3/InceptionC[Mixed_6e]/cat_0" [id=605, type=cat]; +"606 Mixed_7a.branch3x3_1.conv.weight" [id=606, type=nncf_model_const]; +"607 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=607, type=symmetric_quantize]; +"608 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0" [id=608, type=conv2d]; +"609 Mixed_7a.branch3x3_1.bn.weight" [id=609, type=nncf_model_const]; +"610 Mixed_7a.branch3x3_1.bn.bias" [id=610, type=nncf_model_const]; +"611 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0" [id=611, type=batch_norm]; +"612 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/relu__0" [id=612, type=relu_]; +"613 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=613, type=symmetric_quantize]; +"614 Mixed_7a.branch3x3_2.conv.weight" [id=614, type=nncf_model_const]; +"615 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=615, type=symmetric_quantize]; +"616 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/conv2d_0" [id=616, type=conv2d]; +"617 Mixed_7a.branch3x3_2.bn.weight" [id=617, type=nncf_model_const]; +"618 Mixed_7a.branch3x3_2.bn.bias" [id=618, type=nncf_model_const]; +"619 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm_0" [id=619, type=batch_norm]; +"620 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/relu__0" [id=620, type=relu_]; +"621 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize_0" [id=621, type=symmetric_quantize]; +"622 Mixed_7a.branch7x7x3_1.conv.weight" [id=622, type=nncf_model_const]; +"623 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=623, type=symmetric_quantize]; +"624 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/conv2d_0" [id=624, type=conv2d]; +"625 Mixed_7a.branch7x7x3_1.bn.weight" [id=625, type=nncf_model_const]; +"626 Mixed_7a.branch7x7x3_1.bn.bias" [id=626, type=nncf_model_const]; +"627 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm_0" [id=627, type=batch_norm]; +"628 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/relu__0" [id=628, type=relu_]; +"629 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=629, type=symmetric_quantize]; +"630 Mixed_7a.branch7x7x3_2.conv.weight" [id=630, type=nncf_model_const]; +"631 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=631, type=symmetric_quantize]; +"632 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/conv2d_0" [id=632, type=conv2d]; +"633 Mixed_7a.branch7x7x3_2.bn.weight" [id=633, type=nncf_model_const]; +"634 Mixed_7a.branch7x7x3_2.bn.bias" [id=634, type=nncf_model_const]; +"635 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm_0" [id=635, type=batch_norm]; +"636 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/relu__0" [id=636, type=relu_]; +"637 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/SymmetricQuantizer/symmetric_quantize_0" [id=637, type=symmetric_quantize]; +"638 Mixed_7a.branch7x7x3_3.conv.weight" [id=638, type=nncf_model_const]; +"639 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=639, type=symmetric_quantize]; +"640 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/conv2d_0" [id=640, type=conv2d]; +"641 Mixed_7a.branch7x7x3_3.bn.weight" [id=641, type=nncf_model_const]; +"642 Mixed_7a.branch7x7x3_3.bn.bias" [id=642, type=nncf_model_const]; +"643 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm_0" [id=643, type=batch_norm]; +"644 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/relu__0" [id=644, type=relu_]; +"645 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/SymmetricQuantizer/symmetric_quantize_0" [id=645, type=symmetric_quantize]; +"646 Mixed_7a.branch7x7x3_4.conv.weight" [id=646, type=nncf_model_const]; +"647 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=647, type=symmetric_quantize]; +"648 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/conv2d_0" [id=648, type=conv2d]; +"649 Mixed_7a.branch7x7x3_4.bn.weight" [id=649, type=nncf_model_const]; +"650 Mixed_7a.branch7x7x3_4.bn.bias" [id=650, type=nncf_model_const]; +"651 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm_0" [id=651, type=batch_norm]; +"652 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/relu__0" [id=652, type=relu_]; +"653 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize_0" [id=653, type=symmetric_quantize]; +"654 Inception3/InceptionD[Mixed_7a]/max_pool2d_0" [id=654, type=max_pool2d]; +"655 Inception3/InceptionD[Mixed_7a]/cat_0" [id=655, type=cat]; +"656 Mixed_7b.branch1x1.conv.weight" [id=656, type=nncf_model_const]; +"657 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=657, type=symmetric_quantize]; +"658 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=658, type=conv2d]; +"659 Mixed_7b.branch1x1.bn.weight" [id=659, type=nncf_model_const]; +"660 Mixed_7b.branch1x1.bn.bias" [id=660, type=nncf_model_const]; +"661 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=661, type=batch_norm]; +"662 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/relu__0" [id=662, type=relu_]; +"663 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=663, type=symmetric_quantize]; +"664 Mixed_7b.branch3x3_1.conv.weight" [id=664, type=nncf_model_const]; +"665 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=665, type=symmetric_quantize]; +"666 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0" [id=666, type=conv2d]; +"667 Mixed_7b.branch3x3_1.bn.weight" [id=667, type=nncf_model_const]; +"668 Mixed_7b.branch3x3_1.bn.bias" [id=668, type=nncf_model_const]; +"669 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0" [id=669, type=batch_norm]; +"670 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/relu__0" [id=670, type=relu_]; +"671 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=671, type=symmetric_quantize]; +"672 Mixed_7b.branch3x3_2a.conv.weight" [id=672, type=nncf_model_const]; +"673 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=673, type=symmetric_quantize]; +"674 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0" [id=674, type=conv2d]; +"675 Mixed_7b.branch3x3_2a.bn.weight" [id=675, type=nncf_model_const]; +"676 Mixed_7b.branch3x3_2a.bn.bias" [id=676, type=nncf_model_const]; +"677 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0" [id=677, type=batch_norm]; +"678 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/relu__0" [id=678, type=relu_]; +"679 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" [id=679, type=symmetric_quantize]; +"680 Mixed_7b.branch3x3_2b.conv.weight" [id=680, type=nncf_model_const]; +"681 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=681, type=symmetric_quantize]; +"682 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0" [id=682, type=conv2d]; +"683 Mixed_7b.branch3x3_2b.bn.weight" [id=683, type=nncf_model_const]; +"684 Mixed_7b.branch3x3_2b.bn.bias" [id=684, type=nncf_model_const]; +"685 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0" [id=685, type=batch_norm]; +"686 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/relu__0" [id=686, type=relu_]; +"687 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" [id=687, type=symmetric_quantize]; +"688 Inception3/InceptionE[Mixed_7b]/cat_0" [id=688, type=cat]; +"689 Mixed_7b.branch3x3dbl_1.conv.weight" [id=689, type=nncf_model_const]; +"690 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=690, type=symmetric_quantize]; +"691 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" [id=691, type=conv2d]; +"692 Mixed_7b.branch3x3dbl_1.bn.weight" [id=692, type=nncf_model_const]; +"693 Mixed_7b.branch3x3dbl_1.bn.bias" [id=693, type=nncf_model_const]; +"694 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=694, type=batch_norm]; +"695 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=695, type=relu_]; +"696 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=696, type=symmetric_quantize]; +"697 Mixed_7b.branch3x3dbl_2.conv.weight" [id=697, type=nncf_model_const]; +"698 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=698, type=symmetric_quantize]; +"699 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" [id=699, type=conv2d]; +"700 Mixed_7b.branch3x3dbl_2.bn.weight" [id=700, type=nncf_model_const]; +"701 Mixed_7b.branch3x3dbl_2.bn.bias" [id=701, type=nncf_model_const]; +"702 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=702, type=batch_norm]; +"703 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=703, type=relu_]; +"704 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=704, type=symmetric_quantize]; +"705 Mixed_7b.branch3x3dbl_3a.conv.weight" [id=705, type=nncf_model_const]; +"706 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=706, type=symmetric_quantize]; +"707 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0" [id=707, type=conv2d]; +"708 Mixed_7b.branch3x3dbl_3a.bn.weight" [id=708, type=nncf_model_const]; +"709 Mixed_7b.branch3x3dbl_3a.bn.bias" [id=709, type=nncf_model_const]; +"710 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0" [id=710, type=batch_norm]; +"711 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/relu__0" [id=711, type=relu_]; +"712 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" [id=712, type=symmetric_quantize]; +"713 Mixed_7b.branch3x3dbl_3b.conv.weight" [id=713, type=nncf_model_const]; +"714 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=714, type=symmetric_quantize]; +"715 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0" [id=715, type=conv2d]; +"716 Mixed_7b.branch3x3dbl_3b.bn.weight" [id=716, type=nncf_model_const]; +"717 Mixed_7b.branch3x3dbl_3b.bn.bias" [id=717, type=nncf_model_const]; +"718 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0" [id=718, type=batch_norm]; +"719 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/relu__0" [id=719, type=relu_]; +"720 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" [id=720, type=symmetric_quantize]; +"721 Inception3/InceptionE[Mixed_7b]/cat_1" [id=721, type=cat]; +"722 Inception3/InceptionE[Mixed_7b]/avg_pool2d_0" [id=722, type=avg_pool2d]; +"723 Inception3/InceptionE[Mixed_7b]/SymmetricQuantizer/symmetric_quantize_0" [id=723, type=symmetric_quantize]; +"724 Mixed_7b.branch_pool.conv.weight" [id=724, type=nncf_model_const]; +"725 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=725, type=symmetric_quantize]; +"726 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=726, type=conv2d]; +"727 Mixed_7b.branch_pool.bn.weight" [id=727, type=nncf_model_const]; +"728 Mixed_7b.branch_pool.bn.bias" [id=728, type=nncf_model_const]; +"729 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=729, type=batch_norm]; +"730 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/relu__0" [id=730, type=relu_]; +"731 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=731, type=symmetric_quantize]; +"732 Inception3/InceptionE[Mixed_7b]/cat_2" [id=732, type=cat]; +"733 Mixed_7c.branch1x1.conv.weight" [id=733, type=nncf_model_const]; +"734 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=734, type=symmetric_quantize]; +"735 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" [id=735, type=conv2d]; +"736 Mixed_7c.branch1x1.bn.weight" [id=736, type=nncf_model_const]; +"737 Mixed_7c.branch1x1.bn.bias" [id=737, type=nncf_model_const]; +"738 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" [id=738, type=batch_norm]; +"739 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/relu__0" [id=739, type=relu_]; +"740 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=740, type=symmetric_quantize]; +"741 Mixed_7c.branch3x3_1.conv.weight" [id=741, type=nncf_model_const]; +"742 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=742, type=symmetric_quantize]; +"743 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0" [id=743, type=conv2d]; +"744 Mixed_7c.branch3x3_1.bn.weight" [id=744, type=nncf_model_const]; +"745 Mixed_7c.branch3x3_1.bn.bias" [id=745, type=nncf_model_const]; +"746 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0" [id=746, type=batch_norm]; +"747 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/relu__0" [id=747, type=relu_]; +"748 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" [id=748, type=symmetric_quantize]; +"749 Mixed_7c.branch3x3_2a.conv.weight" [id=749, type=nncf_model_const]; +"750 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=750, type=symmetric_quantize]; +"751 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0" [id=751, type=conv2d]; +"752 Mixed_7c.branch3x3_2a.bn.weight" [id=752, type=nncf_model_const]; +"753 Mixed_7c.branch3x3_2a.bn.bias" [id=753, type=nncf_model_const]; +"754 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0" [id=754, type=batch_norm]; +"755 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/relu__0" [id=755, type=relu_]; +"756 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" [id=756, type=symmetric_quantize]; +"757 Mixed_7c.branch3x3_2b.conv.weight" [id=757, type=nncf_model_const]; +"758 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=758, type=symmetric_quantize]; +"759 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0" [id=759, type=conv2d]; +"760 Mixed_7c.branch3x3_2b.bn.weight" [id=760, type=nncf_model_const]; +"761 Mixed_7c.branch3x3_2b.bn.bias" [id=761, type=nncf_model_const]; +"762 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0" [id=762, type=batch_norm]; +"763 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/relu__0" [id=763, type=relu_]; +"764 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" [id=764, type=symmetric_quantize]; +"765 Inception3/InceptionE[Mixed_7c]/cat_0" [id=765, type=cat]; +"766 Mixed_7c.branch3x3dbl_1.conv.weight" [id=766, type=nncf_model_const]; +"767 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=767, type=symmetric_quantize]; +"768 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" [id=768, type=conv2d]; +"769 Mixed_7c.branch3x3dbl_1.bn.weight" [id=769, type=nncf_model_const]; +"770 Mixed_7c.branch3x3dbl_1.bn.bias" [id=770, type=nncf_model_const]; +"771 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" [id=771, type=batch_norm]; +"772 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/relu__0" [id=772, type=relu_]; +"773 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" [id=773, type=symmetric_quantize]; +"774 Mixed_7c.branch3x3dbl_2.conv.weight" [id=774, type=nncf_model_const]; +"775 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=775, type=symmetric_quantize]; +"776 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" [id=776, type=conv2d]; +"777 Mixed_7c.branch3x3dbl_2.bn.weight" [id=777, type=nncf_model_const]; +"778 Mixed_7c.branch3x3dbl_2.bn.bias" [id=778, type=nncf_model_const]; +"779 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" [id=779, type=batch_norm]; +"780 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/relu__0" [id=780, type=relu_]; +"781 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" [id=781, type=symmetric_quantize]; +"782 Mixed_7c.branch3x3dbl_3a.conv.weight" [id=782, type=nncf_model_const]; +"783 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=783, type=symmetric_quantize]; +"784 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0" [id=784, type=conv2d]; +"785 Mixed_7c.branch3x3dbl_3a.bn.weight" [id=785, type=nncf_model_const]; +"786 Mixed_7c.branch3x3dbl_3a.bn.bias" [id=786, type=nncf_model_const]; +"787 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0" [id=787, type=batch_norm]; +"788 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/relu__0" [id=788, type=relu_]; +"789 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" [id=789, type=symmetric_quantize]; +"790 Mixed_7c.branch3x3dbl_3b.conv.weight" [id=790, type=nncf_model_const]; +"791 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=791, type=symmetric_quantize]; +"792 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0" [id=792, type=conv2d]; +"793 Mixed_7c.branch3x3dbl_3b.bn.weight" [id=793, type=nncf_model_const]; +"794 Mixed_7c.branch3x3dbl_3b.bn.bias" [id=794, type=nncf_model_const]; +"795 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0" [id=795, type=batch_norm]; +"796 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/relu__0" [id=796, type=relu_]; +"797 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" [id=797, type=symmetric_quantize]; +"798 Inception3/InceptionE[Mixed_7c]/cat_1" [id=798, type=cat]; +"799 Inception3/InceptionE[Mixed_7c]/avg_pool2d_0" [id=799, type=avg_pool2d]; +"800 Inception3/InceptionE[Mixed_7c]/SymmetricQuantizer/symmetric_quantize_0" [id=800, type=symmetric_quantize]; +"801 Mixed_7c.branch_pool.conv.weight" [id=801, type=nncf_model_const]; +"802 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=802, type=symmetric_quantize]; +"803 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" [id=803, type=conv2d]; +"804 Mixed_7c.branch_pool.bn.weight" [id=804, type=nncf_model_const]; +"805 Mixed_7c.branch_pool.bn.bias" [id=805, type=nncf_model_const]; +"806 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" [id=806, type=batch_norm]; +"807 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/relu__0" [id=807, type=relu_]; +"808 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" [id=808, type=symmetric_quantize]; +"809 Inception3/InceptionE[Mixed_7c]/cat_2" [id=809, type=cat]; +"810 Inception3/adaptive_avg_pool2d_0" [id=810, type=adaptive_avg_pool2d]; +"811 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=811, type=symmetric_quantize]; +"812 Inception3/dropout_0" [id=812, type=dropout]; +"813 Inception3/view_0" [id=813, type=view]; +"814 fc.weight" [id=814, type=nncf_model_const]; +"815 fc.bias" [id=815, type=nncf_model_const]; +"816 Inception3/Linear[fc]/SymmetricQuantizer/symmetric_quantize_0" [id=816, type=symmetric_quantize]; +"817 Inception3/Linear[fc]/linear_0" [id=817, type=linear]; +"818 /nncf_model_output_0" [id=818, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; "1 SymmetricQuantizer/symmetric_quantize_0" -> "2 Inception3/__getitem___0"; "1 SymmetricQuantizer/symmetric_quantize_0" -> "8 Inception3/__getitem___1"; @@ -556,553 +840,837 @@ strict digraph { "17 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/__mul___2|OUTPUT]/symmetric_quantize_0" -> "18 Inception3/__add___2"; "18 Inception3/__add___2" -> "19 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/__add___0|OUTPUT;Inception3/__add___1|OUTPUT;Inception3/__add___2|OUTPUT]/symmetric_quantize_2"; "19 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/__add___0|OUTPUT;Inception3/__add___1|OUTPUT;Inception3/__add___2|OUTPUT]/symmetric_quantize_2" -> "20 Inception3/cat_0"; -"20 Inception3/cat_0" -> "22 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d_0"; -"21 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d_0"; -"22 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d_0" -> "23 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"23 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "24 Inception3/BasicConv2d[Conv2d_1a_3x3]/relu__0"; -"24 Inception3/BasicConv2d[Conv2d_1a_3x3]/relu__0" -> "25 Inception3/BasicConv2d[Conv2d_1a_3x3]/SymmetricQuantizer/symmetric_quantize_0"; -"25 Inception3/BasicConv2d[Conv2d_1a_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "27 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d_0"; -"26 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "27 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d_0"; -"27 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d_0" -> "28 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"28 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "29 Inception3/BasicConv2d[Conv2d_2a_3x3]/relu__0"; -"29 Inception3/BasicConv2d[Conv2d_2a_3x3]/relu__0" -> "30 Inception3/BasicConv2d[Conv2d_2a_3x3]/SymmetricQuantizer/symmetric_quantize_0"; -"30 Inception3/BasicConv2d[Conv2d_2a_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "32 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d_0"; -"31 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "32 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d_0"; -"32 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d_0" -> "33 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"33 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "34 Inception3/BasicConv2d[Conv2d_2b_3x3]/relu__0"; -"34 Inception3/BasicConv2d[Conv2d_2b_3x3]/relu__0" -> "35 Inception3/BasicConv2d[Conv2d_2b_3x3]/SymmetricQuantizer/symmetric_quantize_0"; -"35 Inception3/BasicConv2d[Conv2d_2b_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "36 Inception3/max_pool2d_0"; -"36 Inception3/max_pool2d_0" -> "38 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d_0"; -"37 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "38 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d_0"; -"38 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d_0" -> "39 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"39 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "40 Inception3/BasicConv2d[Conv2d_3b_1x1]/relu__0"; -"40 Inception3/BasicConv2d[Conv2d_3b_1x1]/relu__0" -> "41 Inception3/BasicConv2d[Conv2d_3b_1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"41 Inception3/BasicConv2d[Conv2d_3b_1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "43 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d_0"; -"42 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "43 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d_0"; -"43 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d_0" -> "44 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"44 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "45 Inception3/BasicConv2d[Conv2d_4a_3x3]/relu__0"; -"45 Inception3/BasicConv2d[Conv2d_4a_3x3]/relu__0" -> "46 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize_0"; -"46 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "47 Inception3/max_pool2d_1"; -"47 Inception3/max_pool2d_1" -> "49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"47 Inception3/max_pool2d_1" -> "54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0"; -"47 Inception3/max_pool2d_1" -> "64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"47 Inception3/max_pool2d_1" -> "78 Inception3/InceptionA[Mixed_5b]/avg_pool2d_0"; -"48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/relu__0"; -"51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/relu__0" -> "52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "85 Inception3/InceptionA[Mixed_5b]/cat_0"; -"53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0"; -"54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0" -> "55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/relu__0"; -"56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/relu__0" -> "57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0"; -"57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" -> "59 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0"; -"58 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "59 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0"; -"59 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0" -> "60 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"60 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/relu__0"; -"61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/relu__0" -> "62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0"; -"62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" -> "85 Inception3/InceptionA[Mixed_5b]/cat_0"; -"63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "66 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/relu__0"; -"66 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "67 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"67 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "70 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"70 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "71 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/relu__0"; -"71 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "72 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"72 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "74 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"73 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "74 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"74 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "75 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"75 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/relu__0"; -"76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "77 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"77 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "85 Inception3/InceptionA[Mixed_5b]/cat_0"; -"78 Inception3/InceptionA[Mixed_5b]/avg_pool2d_0" -> "79 Inception3/InceptionA[Mixed_5b]/SymmetricQuantizer/symmetric_quantize_0"; -"79 Inception3/InceptionA[Mixed_5b]/SymmetricQuantizer/symmetric_quantize_0" -> "81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"80 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "82 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"82 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "83 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/relu__0"; -"83 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/relu__0" -> "84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "85 Inception3/InceptionA[Mixed_5b]/cat_0"; -"85 Inception3/InceptionA[Mixed_5b]/cat_0" -> "87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"85 Inception3/InceptionA[Mixed_5b]/cat_0" -> "92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0"; -"85 Inception3/InceptionA[Mixed_5b]/cat_0" -> "102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"85 Inception3/InceptionA[Mixed_5b]/cat_0" -> "116 Inception3/InceptionA[Mixed_5c]/avg_pool2d_0"; -"86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/relu__0"; -"89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/relu__0" -> "90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "123 Inception3/InceptionA[Mixed_5c]/cat_0"; -"91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0"; -"92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0" -> "93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/relu__0"; -"94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/relu__0" -> "95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0"; -"95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" -> "97 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0"; -"96 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "97 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0"; -"97 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0" -> "98 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"98 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/relu__0"; -"99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/relu__0" -> "100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0"; -"100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" -> "123 Inception3/InceptionA[Mixed_5c]/cat_0"; -"101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "103 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"103 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "104 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/relu__0"; -"104 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "105 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"105 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "107 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"106 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "107 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"107 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "108 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"108 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "109 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/relu__0"; -"109 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "110 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"110 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "112 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"111 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"112 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "113 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"113 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "114 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/relu__0"; -"114 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "115 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"115 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "123 Inception3/InceptionA[Mixed_5c]/cat_0"; -"116 Inception3/InceptionA[Mixed_5c]/avg_pool2d_0" -> "117 Inception3/InceptionA[Mixed_5c]/SymmetricQuantizer/symmetric_quantize_0"; -"117 Inception3/InceptionA[Mixed_5c]/SymmetricQuantizer/symmetric_quantize_0" -> "119 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"118 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "119 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"119 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "120 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"120 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "121 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/relu__0"; -"121 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/relu__0" -> "122 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"122 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "123 Inception3/InceptionA[Mixed_5c]/cat_0"; -"123 Inception3/InceptionA[Mixed_5c]/cat_0" -> "125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"123 Inception3/InceptionA[Mixed_5c]/cat_0" -> "130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0"; -"123 Inception3/InceptionA[Mixed_5c]/cat_0" -> "140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"123 Inception3/InceptionA[Mixed_5c]/cat_0" -> "154 Inception3/InceptionA[Mixed_5d]/avg_pool2d_0"; -"124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/relu__0"; -"127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/relu__0" -> "128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "161 Inception3/InceptionA[Mixed_5d]/cat_0"; -"129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0"; -"130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d_0" -> "131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/relu__0"; -"132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/relu__0" -> "133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0"; -"133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" -> "135 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0"; -"134 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "135 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0"; -"135 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d_0" -> "136 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"136 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/relu__0"; -"137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/relu__0" -> "138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0"; -"138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" -> "161 Inception3/InceptionA[Mixed_5d]/cat_0"; -"139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "141 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"141 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "142 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/relu__0"; -"142 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "143 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"143 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "145 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"144 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "145 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"145 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "146 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"146 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "147 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/relu__0"; -"147 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "148 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"148 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "150 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"149 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "150 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"150 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "151 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"151 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "152 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/relu__0"; -"152 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "153 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"153 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "161 Inception3/InceptionA[Mixed_5d]/cat_0"; -"154 Inception3/InceptionA[Mixed_5d]/avg_pool2d_0" -> "155 Inception3/InceptionA[Mixed_5d]/SymmetricQuantizer/symmetric_quantize_0"; -"155 Inception3/InceptionA[Mixed_5d]/SymmetricQuantizer/symmetric_quantize_0" -> "157 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"156 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "157 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"157 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "158 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"158 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "159 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/relu__0"; -"159 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/relu__0" -> "160 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"160 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "161 Inception3/InceptionA[Mixed_5d]/cat_0"; -"161 Inception3/InceptionA[Mixed_5d]/cat_0" -> "163 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d_0"; -"161 Inception3/InceptionA[Mixed_5d]/cat_0" -> "168 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"161 Inception3/InceptionA[Mixed_5d]/cat_0" -> "182 Inception3/InceptionB[Mixed_6a]/max_pool2d_0"; -"162 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "163 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d_0"; -"163 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d_0" -> "164 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"164 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "165 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/relu__0"; -"165 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/relu__0" -> "166 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize_0"; -"166 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "183 Inception3/InceptionB[Mixed_6a]/cat_0"; -"167 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "168 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"168 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "169 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"169 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "170 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/relu__0"; -"170 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "171 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"171 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "173 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"172 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "173 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"173 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "174 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"174 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "175 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/relu__0"; -"175 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "176 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"176 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "178 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"177 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "178 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"178 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "179 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"179 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "180 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/relu__0"; -"180 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "181 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"181 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "183 Inception3/InceptionB[Mixed_6a]/cat_0"; -"182 Inception3/InceptionB[Mixed_6a]/max_pool2d_0" -> "183 Inception3/InceptionB[Mixed_6a]/cat_0"; -"183 Inception3/InceptionB[Mixed_6a]/cat_0" -> "185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"183 Inception3/InceptionB[Mixed_6a]/cat_0" -> "190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"183 Inception3/InceptionB[Mixed_6a]/cat_0" -> "205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"183 Inception3/InceptionB[Mixed_6a]/cat_0" -> "229 Inception3/InceptionC[Mixed_6b]/avg_pool2d_0"; -"184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/relu__0"; -"187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/relu__0" -> "188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "236 Inception3/InceptionC[Mixed_6b]/cat_0"; -"189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" -> "191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/relu__0"; -"192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/relu__0" -> "193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; -"193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" -> "196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/relu__0"; -"197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/relu__0" -> "198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; -"198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" -> "201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/relu__0"; -"202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/relu__0" -> "203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; -"203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "236 Inception3/InceptionC[Mixed_6b]/cat_0"; -"204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/relu__0"; -"207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "210 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"209 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "210 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"210 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "211 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"211 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/relu__0"; -"212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "216 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"216 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "217 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/relu__0"; -"217 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "218 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"218 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "220 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"219 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "220 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"220 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" -> "221 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"221 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "222 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/relu__0"; -"222 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "223 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; -"223 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "225 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"224 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"225 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" -> "226 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"226 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "227 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/relu__0"; -"227 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "228 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; -"228 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "236 Inception3/InceptionC[Mixed_6b]/cat_0"; -"229 Inception3/InceptionC[Mixed_6b]/avg_pool2d_0" -> "230 Inception3/InceptionC[Mixed_6b]/SymmetricQuantizer/symmetric_quantize_0"; -"230 Inception3/InceptionC[Mixed_6b]/SymmetricQuantizer/symmetric_quantize_0" -> "232 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"231 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "232 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"232 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "233 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"233 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "234 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/relu__0"; -"234 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/relu__0" -> "235 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"235 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "236 Inception3/InceptionC[Mixed_6b]/cat_0"; -"236 Inception3/InceptionC[Mixed_6b]/cat_0" -> "238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"236 Inception3/InceptionC[Mixed_6b]/cat_0" -> "243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"236 Inception3/InceptionC[Mixed_6b]/cat_0" -> "258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"236 Inception3/InceptionC[Mixed_6b]/cat_0" -> "282 Inception3/InceptionC[Mixed_6c]/avg_pool2d_0"; -"237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/relu__0"; -"240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/relu__0" -> "241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "289 Inception3/InceptionC[Mixed_6c]/cat_0"; -"242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" -> "244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/relu__0"; -"245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/relu__0" -> "246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; -"246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" -> "249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/relu__0"; -"250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/relu__0" -> "251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; -"251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" -> "254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/relu__0"; -"255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/relu__0" -> "256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; -"256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "289 Inception3/InceptionC[Mixed_6c]/cat_0"; -"257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/relu__0"; -"260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "263 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"262 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "263 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"263 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "264 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"264 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/relu__0"; -"265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "269 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"269 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "270 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/relu__0"; -"270 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "271 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"271 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "273 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"272 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "273 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"273 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" -> "274 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"274 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "275 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/relu__0"; -"275 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "276 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; -"276 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "278 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"277 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "278 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"278 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" -> "279 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"279 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "280 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/relu__0"; -"280 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "281 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; -"281 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "289 Inception3/InceptionC[Mixed_6c]/cat_0"; -"282 Inception3/InceptionC[Mixed_6c]/avg_pool2d_0" -> "283 Inception3/InceptionC[Mixed_6c]/SymmetricQuantizer/symmetric_quantize_0"; -"283 Inception3/InceptionC[Mixed_6c]/SymmetricQuantizer/symmetric_quantize_0" -> "285 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"284 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "285 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"285 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "286 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"286 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "287 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/relu__0"; -"287 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/relu__0" -> "288 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"288 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "289 Inception3/InceptionC[Mixed_6c]/cat_0"; -"289 Inception3/InceptionC[Mixed_6c]/cat_0" -> "291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"289 Inception3/InceptionC[Mixed_6c]/cat_0" -> "296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"289 Inception3/InceptionC[Mixed_6c]/cat_0" -> "311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"289 Inception3/InceptionC[Mixed_6c]/cat_0" -> "335 Inception3/InceptionC[Mixed_6d]/avg_pool2d_0"; -"290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/relu__0"; -"293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/relu__0" -> "294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "342 Inception3/InceptionC[Mixed_6d]/cat_0"; -"295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" -> "297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/relu__0"; -"298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/relu__0" -> "299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; -"299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" -> "302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/relu__0"; -"303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/relu__0" -> "304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; -"304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" -> "307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/relu__0"; -"308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/relu__0" -> "309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; -"309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "342 Inception3/InceptionC[Mixed_6d]/cat_0"; -"310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/relu__0"; -"313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "316 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"315 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "316 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"316 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "317 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"317 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/relu__0"; -"318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "322 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"322 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "323 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/relu__0"; -"323 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "324 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"324 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "326 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"325 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "326 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"326 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" -> "327 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"327 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "328 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/relu__0"; -"328 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "329 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; -"329 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "331 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"330 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "331 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"331 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" -> "332 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"332 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "333 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/relu__0"; -"333 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "334 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; -"334 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "342 Inception3/InceptionC[Mixed_6d]/cat_0"; -"335 Inception3/InceptionC[Mixed_6d]/avg_pool2d_0" -> "336 Inception3/InceptionC[Mixed_6d]/SymmetricQuantizer/symmetric_quantize_0"; -"336 Inception3/InceptionC[Mixed_6d]/SymmetricQuantizer/symmetric_quantize_0" -> "338 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"337 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "338 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"338 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "339 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"339 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "340 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/relu__0"; -"340 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/relu__0" -> "341 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"341 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "342 Inception3/InceptionC[Mixed_6d]/cat_0"; -"342 Inception3/InceptionC[Mixed_6d]/cat_0" -> "344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"342 Inception3/InceptionC[Mixed_6d]/cat_0" -> "349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"342 Inception3/InceptionC[Mixed_6d]/cat_0" -> "364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"342 Inception3/InceptionC[Mixed_6d]/cat_0" -> "388 Inception3/InceptionC[Mixed_6e]/avg_pool2d_0"; -"343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/relu__0"; -"346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/relu__0" -> "347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "395 Inception3/InceptionC[Mixed_6e]/cat_0"; -"348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0"; -"349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d_0" -> "350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/relu__0"; -"351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/relu__0" -> "352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; -"352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0"; -"354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d_0" -> "355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/relu__0"; -"356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/relu__0" -> "357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; -"357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0"; -"359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d_0" -> "360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/relu__0"; -"361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/relu__0" -> "362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; -"362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "395 Inception3/InceptionC[Mixed_6e]/cat_0"; -"363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/relu__0"; -"366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "369 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"368 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "369 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"369 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "370 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"370 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/relu__0"; -"371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0"; -"374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d_0" -> "375 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"375 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "376 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/relu__0"; -"376 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "377 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; -"377 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "379 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"378 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "379 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0"; -"379 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d_0" -> "380 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"380 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "381 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/relu__0"; -"381 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "382 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; -"382 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "384 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"383 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "384 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0"; -"384 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d_0" -> "385 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"385 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "386 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/relu__0"; -"386 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "387 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; -"387 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "395 Inception3/InceptionC[Mixed_6e]/cat_0"; -"388 Inception3/InceptionC[Mixed_6e]/avg_pool2d_0" -> "389 Inception3/InceptionC[Mixed_6e]/SymmetricQuantizer/symmetric_quantize_0"; -"389 Inception3/InceptionC[Mixed_6e]/SymmetricQuantizer/symmetric_quantize_0" -> "391 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"390 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "391 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"391 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "392 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"392 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "393 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/relu__0"; -"393 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/relu__0" -> "394 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"394 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "395 Inception3/InceptionC[Mixed_6e]/cat_0"; -"395 Inception3/InceptionC[Mixed_6e]/cat_0" -> "397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0"; -"395 Inception3/InceptionC[Mixed_6e]/cat_0" -> "407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d_0"; -"395 Inception3/InceptionC[Mixed_6e]/cat_0" -> "426 Inception3/InceptionD[Mixed_7a]/max_pool2d_0"; -"396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0"; -"397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0" -> "398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/relu__0"; -"399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/relu__0" -> "400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0"; -"400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d_0"; -"401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d_0"; -"402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d_0" -> "403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/relu__0"; -"404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/relu__0" -> "405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize_0"; -"405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize_0" -> "427 Inception3/InceptionD[Mixed_7a]/cat_0"; -"406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d_0"; -"407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d_0" -> "408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/relu__0"; -"409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/relu__0" -> "410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/SymmetricQuantizer/symmetric_quantize_0"; -"410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d_0"; -"411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d_0"; -"412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d_0" -> "413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/relu__0"; -"414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/relu__0" -> "415 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/SymmetricQuantizer/symmetric_quantize_0"; -"415 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/SymmetricQuantizer/symmetric_quantize_0" -> "417 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d_0"; -"416 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "417 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d_0"; -"417 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d_0" -> "418 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"418 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "419 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/relu__0"; -"419 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/relu__0" -> "420 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/SymmetricQuantizer/symmetric_quantize_0"; -"420 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/SymmetricQuantizer/symmetric_quantize_0" -> "422 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d_0"; -"421 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "422 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d_0"; -"422 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d_0" -> "423 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"423 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "424 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/relu__0"; -"424 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/relu__0" -> "425 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize_0"; -"425 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize_0" -> "427 Inception3/InceptionD[Mixed_7a]/cat_0"; -"426 Inception3/InceptionD[Mixed_7a]/max_pool2d_0" -> "427 Inception3/InceptionD[Mixed_7a]/cat_0"; -"427 Inception3/InceptionD[Mixed_7a]/cat_0" -> "429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"427 Inception3/InceptionD[Mixed_7a]/cat_0" -> "434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0"; -"427 Inception3/InceptionD[Mixed_7a]/cat_0" -> "450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"427 Inception3/InceptionD[Mixed_7a]/cat_0" -> "470 Inception3/InceptionE[Mixed_7b]/avg_pool2d_0"; -"428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/relu__0"; -"431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/relu__0" -> "432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "477 Inception3/InceptionE[Mixed_7b]/cat_2"; -"433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0"; -"434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0" -> "435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/relu__0"; -"436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/relu__0" -> "437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0"; -"437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0"; -"437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0"; -"438 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0"; -"439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0" -> "440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/relu__0"; -"441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/relu__0" -> "442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0"; -"442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" -> "448 Inception3/InceptionE[Mixed_7b]/cat_0"; -"443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0"; -"444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0" -> "445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/relu__0"; -"446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/relu__0" -> "447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0"; -"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" -> "448 Inception3/InceptionE[Mixed_7b]/cat_0"; -"448 Inception3/InceptionE[Mixed_7b]/cat_0" -> "477 Inception3/InceptionE[Mixed_7b]/cat_2"; -"449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/relu__0"; -"452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/relu__0"; -"457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "460 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0"; -"458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0"; -"459 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "460 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0"; -"460 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0" -> "461 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"461 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/relu__0"; -"462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/relu__0" -> "463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0"; -"463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" -> "469 Inception3/InceptionE[Mixed_7b]/cat_1"; -"464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0"; -"465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0" -> "466 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"466 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "467 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/relu__0"; -"467 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/relu__0" -> "468 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0"; -"468 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" -> "469 Inception3/InceptionE[Mixed_7b]/cat_1"; -"469 Inception3/InceptionE[Mixed_7b]/cat_1" -> "477 Inception3/InceptionE[Mixed_7b]/cat_2"; -"470 Inception3/InceptionE[Mixed_7b]/avg_pool2d_0" -> "471 Inception3/InceptionE[Mixed_7b]/SymmetricQuantizer/symmetric_quantize_0"; -"471 Inception3/InceptionE[Mixed_7b]/SymmetricQuantizer/symmetric_quantize_0" -> "473 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"472 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "473 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"473 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "474 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"474 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "475 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/relu__0"; -"475 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/relu__0" -> "476 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"476 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "477 Inception3/InceptionE[Mixed_7b]/cat_2"; -"477 Inception3/InceptionE[Mixed_7b]/cat_2" -> "479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"477 Inception3/InceptionE[Mixed_7b]/cat_2" -> "484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0"; -"477 Inception3/InceptionE[Mixed_7b]/cat_2" -> "500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"477 Inception3/InceptionE[Mixed_7b]/cat_2" -> "520 Inception3/InceptionE[Mixed_7c]/avg_pool2d_0"; -"478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0"; -"479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d_0" -> "480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/relu__0"; -"481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/relu__0" -> "482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; -"482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "527 Inception3/InceptionE[Mixed_7c]/cat_2"; -"483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0"; -"484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d_0" -> "485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/relu__0"; -"486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/relu__0" -> "487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0"; -"487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0"; -"487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0"; -"488 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0"; -"489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d_0" -> "490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/relu__0"; -"491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/relu__0" -> "492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0"; -"492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" -> "498 Inception3/InceptionE[Mixed_7c]/cat_0"; -"493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0"; -"494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d_0" -> "495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/relu__0"; -"496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/relu__0" -> "497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0"; -"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" -> "498 Inception3/InceptionE[Mixed_7c]/cat_0"; -"498 Inception3/InceptionE[Mixed_7c]/cat_0" -> "527 Inception3/InceptionE[Mixed_7c]/cat_2"; -"499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0"; -"500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d_0" -> "501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/relu__0"; -"502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; -"503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0"; -"505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d_0" -> "506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/relu__0"; -"507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; -"508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "510 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0"; -"508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0"; -"509 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "510 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0"; -"510 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d_0" -> "511 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"511 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/relu__0"; -"512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/relu__0" -> "513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0"; -"513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" -> "519 Inception3/InceptionE[Mixed_7c]/cat_1"; -"514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0"; -"515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d_0" -> "516 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"516 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "517 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/relu__0"; -"517 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/relu__0" -> "518 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0"; -"518 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" -> "519 Inception3/InceptionE[Mixed_7c]/cat_1"; -"519 Inception3/InceptionE[Mixed_7c]/cat_1" -> "527 Inception3/InceptionE[Mixed_7c]/cat_2"; -"520 Inception3/InceptionE[Mixed_7c]/avg_pool2d_0" -> "521 Inception3/InceptionE[Mixed_7c]/SymmetricQuantizer/symmetric_quantize_0"; -"521 Inception3/InceptionE[Mixed_7c]/SymmetricQuantizer/symmetric_quantize_0" -> "523 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"522 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "523 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0"; -"523 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d_0" -> "524 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0"; -"524 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "525 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/relu__0"; -"525 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/relu__0" -> "526 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; -"526 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "527 Inception3/InceptionE[Mixed_7c]/cat_2"; -"527 Inception3/InceptionE[Mixed_7c]/cat_2" -> "528 Inception3/adaptive_avg_pool2d_0"; -"528 Inception3/adaptive_avg_pool2d_0" -> "529 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; -"529 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "530 Inception3/dropout_0"; -"530 Inception3/dropout_0" -> "531 Inception3/view_0"; -"531 Inception3/view_0" -> "533 Inception3/NNCFLinear[fc]/linear_0"; -"532 Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "533 Inception3/NNCFLinear[fc]/linear_0"; -"533 Inception3/NNCFLinear[fc]/linear_0" -> "534 /nncf_model_output_0"; +"20 Inception3/cat_0" -> "23 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/conv2d_0"; +"21 Conv2d_1a_3x3.conv.weight" -> "22 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"22 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "23 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/conv2d_0"; +"23 Inception3/BasicConv2d[Conv2d_1a_3x3]/Conv2d[conv]/conv2d_0" -> "26 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"24 Conv2d_1a_3x3.bn.weight" -> "26 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"25 Conv2d_1a_3x3.bn.bias" -> "26 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"26 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm_0" -> "27 Inception3/BasicConv2d[Conv2d_1a_3x3]/relu__0"; +"27 Inception3/BasicConv2d[Conv2d_1a_3x3]/relu__0" -> "28 Inception3/BasicConv2d[Conv2d_1a_3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"28 Inception3/BasicConv2d[Conv2d_1a_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "31 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d_0"; +"29 Conv2d_2a_3x3.conv.weight" -> "30 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"30 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "31 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d_0"; +"31 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d_0" -> "34 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"32 Conv2d_2a_3x3.bn.weight" -> "34 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"33 Conv2d_2a_3x3.bn.bias" -> "34 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"34 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm_0" -> "35 Inception3/BasicConv2d[Conv2d_2a_3x3]/relu__0"; +"35 Inception3/BasicConv2d[Conv2d_2a_3x3]/relu__0" -> "36 Inception3/BasicConv2d[Conv2d_2a_3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"36 Inception3/BasicConv2d[Conv2d_2a_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "39 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/conv2d_0"; +"37 Conv2d_2b_3x3.conv.weight" -> "38 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"38 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "39 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/conv2d_0"; +"39 Inception3/BasicConv2d[Conv2d_2b_3x3]/Conv2d[conv]/conv2d_0" -> "42 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"40 Conv2d_2b_3x3.bn.weight" -> "42 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"41 Conv2d_2b_3x3.bn.bias" -> "42 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"42 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm_0" -> "43 Inception3/BasicConv2d[Conv2d_2b_3x3]/relu__0"; +"43 Inception3/BasicConv2d[Conv2d_2b_3x3]/relu__0" -> "44 Inception3/BasicConv2d[Conv2d_2b_3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"44 Inception3/BasicConv2d[Conv2d_2b_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "45 Inception3/max_pool2d_0"; +"45 Inception3/max_pool2d_0" -> "48 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/conv2d_0"; +"46 Conv2d_3b_1x1.conv.weight" -> "47 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"47 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "48 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/conv2d_0"; +"48 Inception3/BasicConv2d[Conv2d_3b_1x1]/Conv2d[conv]/conv2d_0" -> "51 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm_0"; +"49 Conv2d_3b_1x1.bn.weight" -> "51 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm_0"; +"50 Conv2d_3b_1x1.bn.bias" -> "51 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm_0"; +"51 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm_0" -> "52 Inception3/BasicConv2d[Conv2d_3b_1x1]/relu__0"; +"52 Inception3/BasicConv2d[Conv2d_3b_1x1]/relu__0" -> "53 Inception3/BasicConv2d[Conv2d_3b_1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"53 Inception3/BasicConv2d[Conv2d_3b_1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "56 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/conv2d_0"; +"54 Conv2d_4a_3x3.conv.weight" -> "55 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"55 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "56 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/conv2d_0"; +"56 Inception3/BasicConv2d[Conv2d_4a_3x3]/Conv2d[conv]/conv2d_0" -> "59 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"57 Conv2d_4a_3x3.bn.weight" -> "59 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"58 Conv2d_4a_3x3.bn.bias" -> "59 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm_0"; +"59 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm_0" -> "60 Inception3/BasicConv2d[Conv2d_4a_3x3]/relu__0"; +"60 Inception3/BasicConv2d[Conv2d_4a_3x3]/relu__0" -> "61 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"61 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "62 Inception3/max_pool2d_1"; +"62 Inception3/max_pool2d_1" -> "65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"62 Inception3/max_pool2d_1" -> "73 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0"; +"62 Inception3/max_pool2d_1" -> "89 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"62 Inception3/max_pool2d_1" -> "111 Inception3/InceptionA[Mixed_5b]/avg_pool2d_0"; +"63 Mixed_5b.branch1x1.conv.weight" -> "64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"66 Mixed_5b.branch1x1.bn.weight" -> "68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"67 Mixed_5b.branch1x1.bn.bias" -> "68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"68 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/relu__0"; +"69 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/relu__0" -> "70 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"70 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "121 Inception3/InceptionA[Mixed_5b]/cat_0"; +"71 Mixed_5b.branch5x5_1.conv.weight" -> "72 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"72 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "73 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0"; +"73 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0" -> "76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"74 Mixed_5b.branch5x5_1.bn.weight" -> "76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"75 Mixed_5b.branch5x5_1.bn.bias" -> "76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"76 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0" -> "77 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/relu__0"; +"77 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/relu__0" -> "78 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0"; +"78 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" -> "81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0"; +"79 Mixed_5b.branch5x5_2.conv.weight" -> "80 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"80 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0"; +"81 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0" -> "84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"82 Mixed_5b.branch5x5_2.bn.weight" -> "84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"83 Mixed_5b.branch5x5_2.bn.bias" -> "84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"84 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0" -> "85 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/relu__0"; +"85 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/relu__0" -> "86 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0"; +"86 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" -> "121 Inception3/InceptionA[Mixed_5b]/cat_0"; +"87 Mixed_5b.branch3x3dbl_1.conv.weight" -> "88 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"88 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "89 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"89 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" -> "92 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"90 Mixed_5b.branch3x3dbl_1.bn.weight" -> "92 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"91 Mixed_5b.branch3x3dbl_1.bn.bias" -> "92 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"92 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "93 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/relu__0"; +"93 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "94 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"94 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "97 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"95 Mixed_5b.branch3x3dbl_2.conv.weight" -> "96 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"96 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "97 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"97 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" -> "100 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"98 Mixed_5b.branch3x3dbl_2.bn.weight" -> "100 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"99 Mixed_5b.branch3x3dbl_2.bn.bias" -> "100 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"100 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "101 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/relu__0"; +"101 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "102 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"102 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "105 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"103 Mixed_5b.branch3x3dbl_3.conv.weight" -> "104 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"104 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "105 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"105 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" -> "108 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"106 Mixed_5b.branch3x3dbl_3.bn.weight" -> "108 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"107 Mixed_5b.branch3x3dbl_3.bn.bias" -> "108 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"108 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "109 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/relu__0"; +"109 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "110 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"110 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "121 Inception3/InceptionA[Mixed_5b]/cat_0"; +"111 Inception3/InceptionA[Mixed_5b]/avg_pool2d_0" -> "112 Inception3/InceptionA[Mixed_5b]/SymmetricQuantizer/symmetric_quantize_0"; +"112 Inception3/InceptionA[Mixed_5b]/SymmetricQuantizer/symmetric_quantize_0" -> "115 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"113 Mixed_5b.branch_pool.conv.weight" -> "114 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"114 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "115 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"115 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "118 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"116 Mixed_5b.branch_pool.bn.weight" -> "118 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"117 Mixed_5b.branch_pool.bn.bias" -> "118 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"118 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "119 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/relu__0"; +"119 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/relu__0" -> "120 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"120 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "121 Inception3/InceptionA[Mixed_5b]/cat_0"; +"121 Inception3/InceptionA[Mixed_5b]/cat_0" -> "124 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"121 Inception3/InceptionA[Mixed_5b]/cat_0" -> "132 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0"; +"121 Inception3/InceptionA[Mixed_5b]/cat_0" -> "148 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"121 Inception3/InceptionA[Mixed_5b]/cat_0" -> "170 Inception3/InceptionA[Mixed_5c]/avg_pool2d_0"; +"122 Mixed_5c.branch1x1.conv.weight" -> "123 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"123 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "124 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"124 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "127 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"125 Mixed_5c.branch1x1.bn.weight" -> "127 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"126 Mixed_5c.branch1x1.bn.bias" -> "127 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"127 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "128 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/relu__0"; +"128 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/relu__0" -> "129 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"129 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "180 Inception3/InceptionA[Mixed_5c]/cat_0"; +"130 Mixed_5c.branch5x5_1.conv.weight" -> "131 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"131 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "132 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0"; +"132 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0" -> "135 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"133 Mixed_5c.branch5x5_1.bn.weight" -> "135 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"134 Mixed_5c.branch5x5_1.bn.bias" -> "135 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"135 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0" -> "136 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/relu__0"; +"136 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/relu__0" -> "137 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0"; +"137 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" -> "140 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0"; +"138 Mixed_5c.branch5x5_2.conv.weight" -> "139 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"139 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "140 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0"; +"140 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0" -> "143 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"141 Mixed_5c.branch5x5_2.bn.weight" -> "143 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"142 Mixed_5c.branch5x5_2.bn.bias" -> "143 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"143 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0" -> "144 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/relu__0"; +"144 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/relu__0" -> "145 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0"; +"145 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" -> "180 Inception3/InceptionA[Mixed_5c]/cat_0"; +"146 Mixed_5c.branch3x3dbl_1.conv.weight" -> "147 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"147 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "148 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"148 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" -> "151 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"149 Mixed_5c.branch3x3dbl_1.bn.weight" -> "151 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"150 Mixed_5c.branch3x3dbl_1.bn.bias" -> "151 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"151 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "152 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/relu__0"; +"152 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "153 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"153 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "156 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"154 Mixed_5c.branch3x3dbl_2.conv.weight" -> "155 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"155 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "156 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"156 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" -> "159 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"157 Mixed_5c.branch3x3dbl_2.bn.weight" -> "159 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"158 Mixed_5c.branch3x3dbl_2.bn.bias" -> "159 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"159 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "160 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/relu__0"; +"160 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "161 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"161 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "164 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"162 Mixed_5c.branch3x3dbl_3.conv.weight" -> "163 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"163 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "164 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"164 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" -> "167 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"165 Mixed_5c.branch3x3dbl_3.bn.weight" -> "167 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"166 Mixed_5c.branch3x3dbl_3.bn.bias" -> "167 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"167 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "168 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/relu__0"; +"168 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "169 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"169 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "180 Inception3/InceptionA[Mixed_5c]/cat_0"; +"170 Inception3/InceptionA[Mixed_5c]/avg_pool2d_0" -> "171 Inception3/InceptionA[Mixed_5c]/SymmetricQuantizer/symmetric_quantize_0"; +"171 Inception3/InceptionA[Mixed_5c]/SymmetricQuantizer/symmetric_quantize_0" -> "174 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"172 Mixed_5c.branch_pool.conv.weight" -> "173 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"173 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "174 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"174 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "177 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"175 Mixed_5c.branch_pool.bn.weight" -> "177 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"176 Mixed_5c.branch_pool.bn.bias" -> "177 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"177 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "178 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/relu__0"; +"178 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/relu__0" -> "179 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"179 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "180 Inception3/InceptionA[Mixed_5c]/cat_0"; +"180 Inception3/InceptionA[Mixed_5c]/cat_0" -> "183 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"180 Inception3/InceptionA[Mixed_5c]/cat_0" -> "191 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0"; +"180 Inception3/InceptionA[Mixed_5c]/cat_0" -> "207 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"180 Inception3/InceptionA[Mixed_5c]/cat_0" -> "229 Inception3/InceptionA[Mixed_5d]/avg_pool2d_0"; +"181 Mixed_5d.branch1x1.conv.weight" -> "182 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"182 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "183 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"183 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "186 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"184 Mixed_5d.branch1x1.bn.weight" -> "186 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"185 Mixed_5d.branch1x1.bn.bias" -> "186 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"186 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "187 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/relu__0"; +"187 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/relu__0" -> "188 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"188 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "239 Inception3/InceptionA[Mixed_5d]/cat_0"; +"189 Mixed_5d.branch5x5_1.conv.weight" -> "190 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"190 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "191 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0"; +"191 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/Conv2d[conv]/conv2d_0" -> "194 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"192 Mixed_5d.branch5x5_1.bn.weight" -> "194 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"193 Mixed_5d.branch5x5_1.bn.bias" -> "194 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0"; +"194 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm_0" -> "195 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/relu__0"; +"195 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/relu__0" -> "196 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0"; +"196 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/SymmetricQuantizer/symmetric_quantize_0" -> "199 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0"; +"197 Mixed_5d.branch5x5_2.conv.weight" -> "198 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"198 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "199 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0"; +"199 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/Conv2d[conv]/conv2d_0" -> "202 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"200 Mixed_5d.branch5x5_2.bn.weight" -> "202 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"201 Mixed_5d.branch5x5_2.bn.bias" -> "202 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0"; +"202 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm_0" -> "203 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/relu__0"; +"203 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/relu__0" -> "204 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0"; +"204 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize_0" -> "239 Inception3/InceptionA[Mixed_5d]/cat_0"; +"205 Mixed_5d.branch3x3dbl_1.conv.weight" -> "206 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"206 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "207 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"207 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" -> "210 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"208 Mixed_5d.branch3x3dbl_1.bn.weight" -> "210 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"209 Mixed_5d.branch3x3dbl_1.bn.bias" -> "210 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"210 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "211 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/relu__0"; +"211 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "212 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"212 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "215 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"213 Mixed_5d.branch3x3dbl_2.conv.weight" -> "214 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"214 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "215 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"215 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" -> "218 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"216 Mixed_5d.branch3x3dbl_2.bn.weight" -> "218 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"217 Mixed_5d.branch3x3dbl_2.bn.bias" -> "218 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"218 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "219 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/relu__0"; +"219 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "220 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"220 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "223 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"221 Mixed_5d.branch3x3dbl_3.conv.weight" -> "222 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"222 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "223 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"223 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" -> "226 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"224 Mixed_5d.branch3x3dbl_3.bn.weight" -> "226 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"225 Mixed_5d.branch3x3dbl_3.bn.bias" -> "226 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"226 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "227 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/relu__0"; +"227 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "228 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"228 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "239 Inception3/InceptionA[Mixed_5d]/cat_0"; +"229 Inception3/InceptionA[Mixed_5d]/avg_pool2d_0" -> "230 Inception3/InceptionA[Mixed_5d]/SymmetricQuantizer/symmetric_quantize_0"; +"230 Inception3/InceptionA[Mixed_5d]/SymmetricQuantizer/symmetric_quantize_0" -> "233 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"231 Mixed_5d.branch_pool.conv.weight" -> "232 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"232 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "233 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"233 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "236 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"234 Mixed_5d.branch_pool.bn.weight" -> "236 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"235 Mixed_5d.branch_pool.bn.bias" -> "236 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"236 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "237 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/relu__0"; +"237 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/relu__0" -> "238 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"238 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "239 Inception3/InceptionA[Mixed_5d]/cat_0"; +"239 Inception3/InceptionA[Mixed_5d]/cat_0" -> "242 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/conv2d_0"; +"239 Inception3/InceptionA[Mixed_5d]/cat_0" -> "250 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"239 Inception3/InceptionA[Mixed_5d]/cat_0" -> "272 Inception3/InceptionB[Mixed_6a]/max_pool2d_0"; +"240 Mixed_6a.branch3x3.conv.weight" -> "241 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"241 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "242 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/conv2d_0"; +"242 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/Conv2d[conv]/conv2d_0" -> "245 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm_0"; +"243 Mixed_6a.branch3x3.bn.weight" -> "245 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm_0"; +"244 Mixed_6a.branch3x3.bn.bias" -> "245 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm_0"; +"245 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm_0" -> "246 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/relu__0"; +"246 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/relu__0" -> "247 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"247 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "273 Inception3/InceptionB[Mixed_6a]/cat_0"; +"248 Mixed_6a.branch3x3dbl_1.conv.weight" -> "249 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"249 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "250 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"250 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" -> "253 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"251 Mixed_6a.branch3x3dbl_1.bn.weight" -> "253 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"252 Mixed_6a.branch3x3dbl_1.bn.bias" -> "253 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"253 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "254 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/relu__0"; +"254 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "255 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"255 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "258 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"256 Mixed_6a.branch3x3dbl_2.conv.weight" -> "257 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"257 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "258 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"258 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" -> "261 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"259 Mixed_6a.branch3x3dbl_2.bn.weight" -> "261 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"260 Mixed_6a.branch3x3dbl_2.bn.bias" -> "261 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"261 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "262 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/relu__0"; +"262 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "263 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"263 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "266 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"264 Mixed_6a.branch3x3dbl_3.conv.weight" -> "265 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"265 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "266 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0"; +"266 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/Conv2d[conv]/conv2d_0" -> "269 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"267 Mixed_6a.branch3x3dbl_3.bn.weight" -> "269 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"268 Mixed_6a.branch3x3dbl_3.bn.bias" -> "269 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"269 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "270 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/relu__0"; +"270 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/relu__0" -> "271 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"271 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "273 Inception3/InceptionB[Mixed_6a]/cat_0"; +"272 Inception3/InceptionB[Mixed_6a]/max_pool2d_0" -> "273 Inception3/InceptionB[Mixed_6a]/cat_0"; +"273 Inception3/InceptionB[Mixed_6a]/cat_0" -> "276 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"273 Inception3/InceptionB[Mixed_6a]/cat_0" -> "284 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"273 Inception3/InceptionB[Mixed_6a]/cat_0" -> "308 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"273 Inception3/InceptionB[Mixed_6a]/cat_0" -> "346 Inception3/InceptionC[Mixed_6b]/avg_pool2d_0"; +"274 Mixed_6b.branch1x1.conv.weight" -> "275 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"275 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "276 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"276 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "279 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"277 Mixed_6b.branch1x1.bn.weight" -> "279 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"278 Mixed_6b.branch1x1.bn.bias" -> "279 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"279 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "280 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/relu__0"; +"280 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/relu__0" -> "281 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"281 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "356 Inception3/InceptionC[Mixed_6b]/cat_0"; +"282 Mixed_6b.branch7x7_1.conv.weight" -> "283 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"283 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "284 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"284 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" -> "287 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"285 Mixed_6b.branch7x7_1.bn.weight" -> "287 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"286 Mixed_6b.branch7x7_1.bn.bias" -> "287 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"287 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" -> "288 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/relu__0"; +"288 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/relu__0" -> "289 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; +"289 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "292 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"290 Mixed_6b.branch7x7_2.conv.weight" -> "291 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"291 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "292 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"292 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" -> "295 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"293 Mixed_6b.branch7x7_2.bn.weight" -> "295 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"294 Mixed_6b.branch7x7_2.bn.bias" -> "295 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"295 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" -> "296 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/relu__0"; +"296 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/relu__0" -> "297 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; +"297 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "300 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"298 Mixed_6b.branch7x7_3.conv.weight" -> "299 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"299 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "300 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"300 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" -> "303 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"301 Mixed_6b.branch7x7_3.bn.weight" -> "303 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"302 Mixed_6b.branch7x7_3.bn.bias" -> "303 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"303 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" -> "304 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/relu__0"; +"304 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/relu__0" -> "305 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; +"305 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "356 Inception3/InceptionC[Mixed_6b]/cat_0"; +"306 Mixed_6b.branch7x7dbl_1.conv.weight" -> "307 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"307 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "308 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"308 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" -> "311 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"309 Mixed_6b.branch7x7dbl_1.bn.weight" -> "311 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"310 Mixed_6b.branch7x7dbl_1.bn.bias" -> "311 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"311 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "312 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/relu__0"; +"312 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "313 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"313 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "316 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"314 Mixed_6b.branch7x7dbl_2.conv.weight" -> "315 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"315 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "316 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"316 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" -> "319 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"317 Mixed_6b.branch7x7dbl_2.bn.weight" -> "319 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"318 Mixed_6b.branch7x7dbl_2.bn.bias" -> "319 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"319 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "320 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/relu__0"; +"320 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "321 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"321 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "324 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"322 Mixed_6b.branch7x7dbl_3.conv.weight" -> "323 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"323 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "324 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"324 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" -> "327 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"325 Mixed_6b.branch7x7dbl_3.bn.weight" -> "327 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"326 Mixed_6b.branch7x7dbl_3.bn.bias" -> "327 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"327 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "328 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/relu__0"; +"328 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "329 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"329 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "332 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"330 Mixed_6b.branch7x7dbl_4.conv.weight" -> "331 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"331 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "332 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"332 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" -> "335 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"333 Mixed_6b.branch7x7dbl_4.bn.weight" -> "335 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"334 Mixed_6b.branch7x7dbl_4.bn.bias" -> "335 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"335 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" -> "336 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/relu__0"; +"336 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "337 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; +"337 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "340 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"338 Mixed_6b.branch7x7dbl_5.conv.weight" -> "339 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"339 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "340 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"340 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" -> "343 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"341 Mixed_6b.branch7x7dbl_5.bn.weight" -> "343 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"342 Mixed_6b.branch7x7dbl_5.bn.bias" -> "343 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"343 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" -> "344 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/relu__0"; +"344 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "345 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; +"345 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "356 Inception3/InceptionC[Mixed_6b]/cat_0"; +"346 Inception3/InceptionC[Mixed_6b]/avg_pool2d_0" -> "347 Inception3/InceptionC[Mixed_6b]/SymmetricQuantizer/symmetric_quantize_0"; +"347 Inception3/InceptionC[Mixed_6b]/SymmetricQuantizer/symmetric_quantize_0" -> "350 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"348 Mixed_6b.branch_pool.conv.weight" -> "349 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"349 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "350 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"350 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "353 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"351 Mixed_6b.branch_pool.bn.weight" -> "353 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"352 Mixed_6b.branch_pool.bn.bias" -> "353 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"353 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "354 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/relu__0"; +"354 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/relu__0" -> "355 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"355 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "356 Inception3/InceptionC[Mixed_6b]/cat_0"; +"356 Inception3/InceptionC[Mixed_6b]/cat_0" -> "359 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"356 Inception3/InceptionC[Mixed_6b]/cat_0" -> "367 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"356 Inception3/InceptionC[Mixed_6b]/cat_0" -> "391 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"356 Inception3/InceptionC[Mixed_6b]/cat_0" -> "429 Inception3/InceptionC[Mixed_6c]/avg_pool2d_0"; +"357 Mixed_6c.branch1x1.conv.weight" -> "358 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"358 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "359 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"359 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "362 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"360 Mixed_6c.branch1x1.bn.weight" -> "362 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"361 Mixed_6c.branch1x1.bn.bias" -> "362 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"362 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "363 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/relu__0"; +"363 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/relu__0" -> "364 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"364 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "439 Inception3/InceptionC[Mixed_6c]/cat_0"; +"365 Mixed_6c.branch7x7_1.conv.weight" -> "366 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"366 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "367 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"367 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" -> "370 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"368 Mixed_6c.branch7x7_1.bn.weight" -> "370 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"369 Mixed_6c.branch7x7_1.bn.bias" -> "370 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"370 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" -> "371 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/relu__0"; +"371 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/relu__0" -> "372 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; +"372 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "375 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"373 Mixed_6c.branch7x7_2.conv.weight" -> "374 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"374 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "375 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"375 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" -> "378 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"376 Mixed_6c.branch7x7_2.bn.weight" -> "378 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"377 Mixed_6c.branch7x7_2.bn.bias" -> "378 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"378 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" -> "379 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/relu__0"; +"379 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/relu__0" -> "380 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; +"380 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "383 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"381 Mixed_6c.branch7x7_3.conv.weight" -> "382 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"382 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "383 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"383 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" -> "386 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"384 Mixed_6c.branch7x7_3.bn.weight" -> "386 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"385 Mixed_6c.branch7x7_3.bn.bias" -> "386 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"386 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" -> "387 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/relu__0"; +"387 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/relu__0" -> "388 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; +"388 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "439 Inception3/InceptionC[Mixed_6c]/cat_0"; +"389 Mixed_6c.branch7x7dbl_1.conv.weight" -> "390 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"390 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "391 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"391 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" -> "394 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"392 Mixed_6c.branch7x7dbl_1.bn.weight" -> "394 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"393 Mixed_6c.branch7x7dbl_1.bn.bias" -> "394 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"394 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "395 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/relu__0"; +"395 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "396 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"396 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "399 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"397 Mixed_6c.branch7x7dbl_2.conv.weight" -> "398 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"398 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "399 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"399 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" -> "402 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"400 Mixed_6c.branch7x7dbl_2.bn.weight" -> "402 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"401 Mixed_6c.branch7x7dbl_2.bn.bias" -> "402 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"402 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "403 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/relu__0"; +"403 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "404 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"404 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "407 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"405 Mixed_6c.branch7x7dbl_3.conv.weight" -> "406 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"406 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "407 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"407 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" -> "410 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"408 Mixed_6c.branch7x7dbl_3.bn.weight" -> "410 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"409 Mixed_6c.branch7x7dbl_3.bn.bias" -> "410 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"410 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "411 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/relu__0"; +"411 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "412 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"412 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "415 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"413 Mixed_6c.branch7x7dbl_4.conv.weight" -> "414 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"414 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "415 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"415 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" -> "418 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"416 Mixed_6c.branch7x7dbl_4.bn.weight" -> "418 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"417 Mixed_6c.branch7x7dbl_4.bn.bias" -> "418 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"418 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" -> "419 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/relu__0"; +"419 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "420 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; +"420 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "423 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"421 Mixed_6c.branch7x7dbl_5.conv.weight" -> "422 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"422 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "423 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"423 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" -> "426 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"424 Mixed_6c.branch7x7dbl_5.bn.weight" -> "426 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"425 Mixed_6c.branch7x7dbl_5.bn.bias" -> "426 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"426 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" -> "427 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/relu__0"; +"427 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "428 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; +"428 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "439 Inception3/InceptionC[Mixed_6c]/cat_0"; +"429 Inception3/InceptionC[Mixed_6c]/avg_pool2d_0" -> "430 Inception3/InceptionC[Mixed_6c]/SymmetricQuantizer/symmetric_quantize_0"; +"430 Inception3/InceptionC[Mixed_6c]/SymmetricQuantizer/symmetric_quantize_0" -> "433 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"431 Mixed_6c.branch_pool.conv.weight" -> "432 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"432 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "433 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"433 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "436 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"434 Mixed_6c.branch_pool.bn.weight" -> "436 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"435 Mixed_6c.branch_pool.bn.bias" -> "436 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"436 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "437 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/relu__0"; +"437 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/relu__0" -> "438 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"438 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "439 Inception3/InceptionC[Mixed_6c]/cat_0"; +"439 Inception3/InceptionC[Mixed_6c]/cat_0" -> "442 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"439 Inception3/InceptionC[Mixed_6c]/cat_0" -> "450 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"439 Inception3/InceptionC[Mixed_6c]/cat_0" -> "474 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"439 Inception3/InceptionC[Mixed_6c]/cat_0" -> "512 Inception3/InceptionC[Mixed_6d]/avg_pool2d_0"; +"440 Mixed_6d.branch1x1.conv.weight" -> "441 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"441 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "442 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"442 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "445 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"443 Mixed_6d.branch1x1.bn.weight" -> "445 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"444 Mixed_6d.branch1x1.bn.bias" -> "445 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"445 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "446 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/relu__0"; +"446 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/relu__0" -> "447 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"447 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "522 Inception3/InceptionC[Mixed_6d]/cat_0"; +"448 Mixed_6d.branch7x7_1.conv.weight" -> "449 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"449 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "450 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"450 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" -> "453 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"451 Mixed_6d.branch7x7_1.bn.weight" -> "453 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"452 Mixed_6d.branch7x7_1.bn.bias" -> "453 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"453 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" -> "454 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/relu__0"; +"454 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/relu__0" -> "455 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; +"455 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "458 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"456 Mixed_6d.branch7x7_2.conv.weight" -> "457 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"457 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "458 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"458 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" -> "461 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"459 Mixed_6d.branch7x7_2.bn.weight" -> "461 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"460 Mixed_6d.branch7x7_2.bn.bias" -> "461 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"461 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" -> "462 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/relu__0"; +"462 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/relu__0" -> "463 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; +"463 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "466 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"464 Mixed_6d.branch7x7_3.conv.weight" -> "465 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"465 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "466 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"466 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" -> "469 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"467 Mixed_6d.branch7x7_3.bn.weight" -> "469 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"468 Mixed_6d.branch7x7_3.bn.bias" -> "469 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"469 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" -> "470 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/relu__0"; +"470 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/relu__0" -> "471 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; +"471 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "522 Inception3/InceptionC[Mixed_6d]/cat_0"; +"472 Mixed_6d.branch7x7dbl_1.conv.weight" -> "473 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"473 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "474 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"474 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" -> "477 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"475 Mixed_6d.branch7x7dbl_1.bn.weight" -> "477 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"476 Mixed_6d.branch7x7dbl_1.bn.bias" -> "477 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"477 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "478 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/relu__0"; +"478 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "479 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"479 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "482 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"480 Mixed_6d.branch7x7dbl_2.conv.weight" -> "481 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"481 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "482 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"482 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" -> "485 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"483 Mixed_6d.branch7x7dbl_2.bn.weight" -> "485 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"484 Mixed_6d.branch7x7dbl_2.bn.bias" -> "485 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"485 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "486 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/relu__0"; +"486 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "487 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"487 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "490 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"488 Mixed_6d.branch7x7dbl_3.conv.weight" -> "489 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"489 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "490 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"490 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" -> "493 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"491 Mixed_6d.branch7x7dbl_3.bn.weight" -> "493 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"492 Mixed_6d.branch7x7dbl_3.bn.bias" -> "493 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"493 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "494 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/relu__0"; +"494 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "495 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"495 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "498 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"496 Mixed_6d.branch7x7dbl_4.conv.weight" -> "497 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"497 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "498 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"498 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" -> "501 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"499 Mixed_6d.branch7x7dbl_4.bn.weight" -> "501 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"500 Mixed_6d.branch7x7dbl_4.bn.bias" -> "501 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"501 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" -> "502 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/relu__0"; +"502 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "503 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; +"503 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "506 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"504 Mixed_6d.branch7x7dbl_5.conv.weight" -> "505 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"505 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "506 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"506 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" -> "509 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"507 Mixed_6d.branch7x7dbl_5.bn.weight" -> "509 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"508 Mixed_6d.branch7x7dbl_5.bn.bias" -> "509 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"509 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" -> "510 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/relu__0"; +"510 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "511 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; +"511 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "522 Inception3/InceptionC[Mixed_6d]/cat_0"; +"512 Inception3/InceptionC[Mixed_6d]/avg_pool2d_0" -> "513 Inception3/InceptionC[Mixed_6d]/SymmetricQuantizer/symmetric_quantize_0"; +"513 Inception3/InceptionC[Mixed_6d]/SymmetricQuantizer/symmetric_quantize_0" -> "516 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"514 Mixed_6d.branch_pool.conv.weight" -> "515 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"515 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "516 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"516 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "519 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"517 Mixed_6d.branch_pool.bn.weight" -> "519 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"518 Mixed_6d.branch_pool.bn.bias" -> "519 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"519 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "520 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/relu__0"; +"520 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/relu__0" -> "521 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"521 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "522 Inception3/InceptionC[Mixed_6d]/cat_0"; +"522 Inception3/InceptionC[Mixed_6d]/cat_0" -> "525 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"522 Inception3/InceptionC[Mixed_6d]/cat_0" -> "533 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"522 Inception3/InceptionC[Mixed_6d]/cat_0" -> "557 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"522 Inception3/InceptionC[Mixed_6d]/cat_0" -> "595 Inception3/InceptionC[Mixed_6e]/avg_pool2d_0"; +"523 Mixed_6e.branch1x1.conv.weight" -> "524 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"524 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "525 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"525 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "528 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"526 Mixed_6e.branch1x1.bn.weight" -> "528 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"527 Mixed_6e.branch1x1.bn.bias" -> "528 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"528 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "529 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/relu__0"; +"529 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/relu__0" -> "530 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"530 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "605 Inception3/InceptionC[Mixed_6e]/cat_0"; +"531 Mixed_6e.branch7x7_1.conv.weight" -> "532 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"532 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "533 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0"; +"533 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/Conv2d[conv]/conv2d_0" -> "536 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"534 Mixed_6e.branch7x7_1.bn.weight" -> "536 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"535 Mixed_6e.branch7x7_1.bn.bias" -> "536 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0"; +"536 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm_0" -> "537 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/relu__0"; +"537 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/relu__0" -> "538 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0"; +"538 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/SymmetricQuantizer/symmetric_quantize_0" -> "541 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"539 Mixed_6e.branch7x7_2.conv.weight" -> "540 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"540 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "541 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0"; +"541 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/Conv2d[conv]/conv2d_0" -> "544 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"542 Mixed_6e.branch7x7_2.bn.weight" -> "544 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"543 Mixed_6e.branch7x7_2.bn.bias" -> "544 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0"; +"544 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm_0" -> "545 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/relu__0"; +"545 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/relu__0" -> "546 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0"; +"546 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/SymmetricQuantizer/symmetric_quantize_0" -> "549 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"547 Mixed_6e.branch7x7_3.conv.weight" -> "548 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"548 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "549 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0"; +"549 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/Conv2d[conv]/conv2d_0" -> "552 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"550 Mixed_6e.branch7x7_3.bn.weight" -> "552 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"551 Mixed_6e.branch7x7_3.bn.bias" -> "552 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0"; +"552 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm_0" -> "553 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/relu__0"; +"553 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/relu__0" -> "554 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0"; +"554 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize_0" -> "605 Inception3/InceptionC[Mixed_6e]/cat_0"; +"555 Mixed_6e.branch7x7dbl_1.conv.weight" -> "556 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"556 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "557 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0"; +"557 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/Conv2d[conv]/conv2d_0" -> "560 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"558 Mixed_6e.branch7x7dbl_1.bn.weight" -> "560 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"559 Mixed_6e.branch7x7dbl_1.bn.bias" -> "560 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"560 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "561 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/relu__0"; +"561 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/relu__0" -> "562 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"562 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "565 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"563 Mixed_6e.branch7x7dbl_2.conv.weight" -> "564 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"564 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "565 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0"; +"565 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/Conv2d[conv]/conv2d_0" -> "568 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"566 Mixed_6e.branch7x7dbl_2.bn.weight" -> "568 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"567 Mixed_6e.branch7x7dbl_2.bn.bias" -> "568 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"568 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "569 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/relu__0"; +"569 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/relu__0" -> "570 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"570 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "573 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"571 Mixed_6e.branch7x7dbl_3.conv.weight" -> "572 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"572 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "573 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0"; +"573 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/Conv2d[conv]/conv2d_0" -> "576 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"574 Mixed_6e.branch7x7dbl_3.bn.weight" -> "576 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"575 Mixed_6e.branch7x7dbl_3.bn.bias" -> "576 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0"; +"576 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm_0" -> "577 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/relu__0"; +"577 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/relu__0" -> "578 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0"; +"578 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/SymmetricQuantizer/symmetric_quantize_0" -> "581 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"579 Mixed_6e.branch7x7dbl_4.conv.weight" -> "580 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"580 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "581 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0"; +"581 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/Conv2d[conv]/conv2d_0" -> "584 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"582 Mixed_6e.branch7x7dbl_4.bn.weight" -> "584 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"583 Mixed_6e.branch7x7dbl_4.bn.bias" -> "584 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0"; +"584 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm_0" -> "585 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/relu__0"; +"585 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/relu__0" -> "586 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0"; +"586 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/SymmetricQuantizer/symmetric_quantize_0" -> "589 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"587 Mixed_6e.branch7x7dbl_5.conv.weight" -> "588 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"588 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "589 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0"; +"589 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/Conv2d[conv]/conv2d_0" -> "592 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"590 Mixed_6e.branch7x7dbl_5.bn.weight" -> "592 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"591 Mixed_6e.branch7x7dbl_5.bn.bias" -> "592 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0"; +"592 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm_0" -> "593 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/relu__0"; +"593 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/relu__0" -> "594 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0"; +"594 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize_0" -> "605 Inception3/InceptionC[Mixed_6e]/cat_0"; +"595 Inception3/InceptionC[Mixed_6e]/avg_pool2d_0" -> "596 Inception3/InceptionC[Mixed_6e]/SymmetricQuantizer/symmetric_quantize_0"; +"596 Inception3/InceptionC[Mixed_6e]/SymmetricQuantizer/symmetric_quantize_0" -> "599 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"597 Mixed_6e.branch_pool.conv.weight" -> "598 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"598 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "599 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"599 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "602 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"600 Mixed_6e.branch_pool.bn.weight" -> "602 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"601 Mixed_6e.branch_pool.bn.bias" -> "602 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"602 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "603 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/relu__0"; +"603 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/relu__0" -> "604 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"604 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "605 Inception3/InceptionC[Mixed_6e]/cat_0"; +"605 Inception3/InceptionC[Mixed_6e]/cat_0" -> "608 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0"; +"605 Inception3/InceptionC[Mixed_6e]/cat_0" -> "624 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/conv2d_0"; +"605 Inception3/InceptionC[Mixed_6e]/cat_0" -> "654 Inception3/InceptionD[Mixed_7a]/max_pool2d_0"; +"606 Mixed_7a.branch3x3_1.conv.weight" -> "607 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"607 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "608 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0"; +"608 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0" -> "611 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"609 Mixed_7a.branch3x3_1.bn.weight" -> "611 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"610 Mixed_7a.branch3x3_1.bn.bias" -> "611 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"611 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0" -> "612 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/relu__0"; +"612 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/relu__0" -> "613 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0"; +"613 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "616 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/conv2d_0"; +"614 Mixed_7a.branch3x3_2.conv.weight" -> "615 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"615 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "616 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/conv2d_0"; +"616 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/Conv2d[conv]/conv2d_0" -> "619 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm_0"; +"617 Mixed_7a.branch3x3_2.bn.weight" -> "619 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm_0"; +"618 Mixed_7a.branch3x3_2.bn.bias" -> "619 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm_0"; +"619 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm_0" -> "620 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/relu__0"; +"620 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/relu__0" -> "621 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize_0"; +"621 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize_0" -> "655 Inception3/InceptionD[Mixed_7a]/cat_0"; +"622 Mixed_7a.branch7x7x3_1.conv.weight" -> "623 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"623 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "624 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/conv2d_0"; +"624 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/Conv2d[conv]/conv2d_0" -> "627 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"625 Mixed_7a.branch7x7x3_1.bn.weight" -> "627 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"626 Mixed_7a.branch7x7x3_1.bn.bias" -> "627 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"627 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm_0" -> "628 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/relu__0"; +"628 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/relu__0" -> "629 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/SymmetricQuantizer/symmetric_quantize_0"; +"629 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "632 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/conv2d_0"; +"630 Mixed_7a.branch7x7x3_2.conv.weight" -> "631 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"631 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "632 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/conv2d_0"; +"632 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/Conv2d[conv]/conv2d_0" -> "635 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm_0"; +"633 Mixed_7a.branch7x7x3_2.bn.weight" -> "635 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm_0"; +"634 Mixed_7a.branch7x7x3_2.bn.bias" -> "635 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm_0"; +"635 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm_0" -> "636 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/relu__0"; +"636 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/relu__0" -> "637 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/SymmetricQuantizer/symmetric_quantize_0"; +"637 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/SymmetricQuantizer/symmetric_quantize_0" -> "640 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/conv2d_0"; +"638 Mixed_7a.branch7x7x3_3.conv.weight" -> "639 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"639 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "640 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/conv2d_0"; +"640 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/Conv2d[conv]/conv2d_0" -> "643 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm_0"; +"641 Mixed_7a.branch7x7x3_3.bn.weight" -> "643 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm_0"; +"642 Mixed_7a.branch7x7x3_3.bn.bias" -> "643 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm_0"; +"643 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm_0" -> "644 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/relu__0"; +"644 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/relu__0" -> "645 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/SymmetricQuantizer/symmetric_quantize_0"; +"645 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/SymmetricQuantizer/symmetric_quantize_0" -> "648 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/conv2d_0"; +"646 Mixed_7a.branch7x7x3_4.conv.weight" -> "647 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"647 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "648 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/conv2d_0"; +"648 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/Conv2d[conv]/conv2d_0" -> "651 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm_0"; +"649 Mixed_7a.branch7x7x3_4.bn.weight" -> "651 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm_0"; +"650 Mixed_7a.branch7x7x3_4.bn.bias" -> "651 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm_0"; +"651 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm_0" -> "652 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/relu__0"; +"652 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/relu__0" -> "653 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize_0"; +"653 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize_0" -> "655 Inception3/InceptionD[Mixed_7a]/cat_0"; +"654 Inception3/InceptionD[Mixed_7a]/max_pool2d_0" -> "655 Inception3/InceptionD[Mixed_7a]/cat_0"; +"655 Inception3/InceptionD[Mixed_7a]/cat_0" -> "658 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"655 Inception3/InceptionD[Mixed_7a]/cat_0" -> "666 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0"; +"655 Inception3/InceptionD[Mixed_7a]/cat_0" -> "691 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"655 Inception3/InceptionD[Mixed_7a]/cat_0" -> "722 Inception3/InceptionE[Mixed_7b]/avg_pool2d_0"; +"656 Mixed_7b.branch1x1.conv.weight" -> "657 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"657 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "658 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"658 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "661 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"659 Mixed_7b.branch1x1.bn.weight" -> "661 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"660 Mixed_7b.branch1x1.bn.bias" -> "661 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"661 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "662 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/relu__0"; +"662 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/relu__0" -> "663 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"663 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "732 Inception3/InceptionE[Mixed_7b]/cat_2"; +"664 Mixed_7b.branch3x3_1.conv.weight" -> "665 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"665 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "666 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0"; +"666 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0" -> "669 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"667 Mixed_7b.branch3x3_1.bn.weight" -> "669 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"668 Mixed_7b.branch3x3_1.bn.bias" -> "669 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"669 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0" -> "670 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/relu__0"; +"670 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/relu__0" -> "671 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0"; +"671 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "674 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0"; +"671 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "682 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0"; +"672 Mixed_7b.branch3x3_2a.conv.weight" -> "673 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"673 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "674 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0"; +"674 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0" -> "677 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0"; +"675 Mixed_7b.branch3x3_2a.bn.weight" -> "677 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0"; +"676 Mixed_7b.branch3x3_2a.bn.bias" -> "677 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0"; +"677 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0" -> "678 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/relu__0"; +"678 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/relu__0" -> "679 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0"; +"679 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" -> "688 Inception3/InceptionE[Mixed_7b]/cat_0"; +"680 Mixed_7b.branch3x3_2b.conv.weight" -> "681 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"681 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "682 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0"; +"682 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0" -> "685 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0"; +"683 Mixed_7b.branch3x3_2b.bn.weight" -> "685 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0"; +"684 Mixed_7b.branch3x3_2b.bn.bias" -> "685 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0"; +"685 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0" -> "686 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/relu__0"; +"686 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/relu__0" -> "687 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0"; +"687 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" -> "688 Inception3/InceptionE[Mixed_7b]/cat_0"; +"688 Inception3/InceptionE[Mixed_7b]/cat_0" -> "732 Inception3/InceptionE[Mixed_7b]/cat_2"; +"689 Mixed_7b.branch3x3dbl_1.conv.weight" -> "690 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"690 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "691 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"691 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" -> "694 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"692 Mixed_7b.branch3x3dbl_1.bn.weight" -> "694 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"693 Mixed_7b.branch3x3dbl_1.bn.bias" -> "694 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"694 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "695 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/relu__0"; +"695 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "696 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"696 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "699 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"697 Mixed_7b.branch3x3dbl_2.conv.weight" -> "698 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"698 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "699 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"699 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" -> "702 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"700 Mixed_7b.branch3x3dbl_2.bn.weight" -> "702 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"701 Mixed_7b.branch3x3dbl_2.bn.bias" -> "702 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"702 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "703 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/relu__0"; +"703 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "704 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"704 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "707 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0"; +"704 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "715 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0"; +"705 Mixed_7b.branch3x3dbl_3a.conv.weight" -> "706 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"706 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "707 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0"; +"707 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0" -> "710 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0"; +"708 Mixed_7b.branch3x3dbl_3a.bn.weight" -> "710 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0"; +"709 Mixed_7b.branch3x3dbl_3a.bn.bias" -> "710 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0"; +"710 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0" -> "711 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/relu__0"; +"711 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/relu__0" -> "712 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0"; +"712 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" -> "721 Inception3/InceptionE[Mixed_7b]/cat_1"; +"713 Mixed_7b.branch3x3dbl_3b.conv.weight" -> "714 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"714 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "715 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0"; +"715 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0" -> "718 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0"; +"716 Mixed_7b.branch3x3dbl_3b.bn.weight" -> "718 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0"; +"717 Mixed_7b.branch3x3dbl_3b.bn.bias" -> "718 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0"; +"718 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0" -> "719 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/relu__0"; +"719 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/relu__0" -> "720 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0"; +"720 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" -> "721 Inception3/InceptionE[Mixed_7b]/cat_1"; +"721 Inception3/InceptionE[Mixed_7b]/cat_1" -> "732 Inception3/InceptionE[Mixed_7b]/cat_2"; +"722 Inception3/InceptionE[Mixed_7b]/avg_pool2d_0" -> "723 Inception3/InceptionE[Mixed_7b]/SymmetricQuantizer/symmetric_quantize_0"; +"723 Inception3/InceptionE[Mixed_7b]/SymmetricQuantizer/symmetric_quantize_0" -> "726 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"724 Mixed_7b.branch_pool.conv.weight" -> "725 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"725 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "726 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"726 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "729 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"727 Mixed_7b.branch_pool.bn.weight" -> "729 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"728 Mixed_7b.branch_pool.bn.bias" -> "729 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"729 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "730 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/relu__0"; +"730 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/relu__0" -> "731 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"731 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "732 Inception3/InceptionE[Mixed_7b]/cat_2"; +"732 Inception3/InceptionE[Mixed_7b]/cat_2" -> "735 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"732 Inception3/InceptionE[Mixed_7b]/cat_2" -> "743 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0"; +"732 Inception3/InceptionE[Mixed_7b]/cat_2" -> "768 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"732 Inception3/InceptionE[Mixed_7b]/cat_2" -> "799 Inception3/InceptionE[Mixed_7c]/avg_pool2d_0"; +"733 Mixed_7c.branch1x1.conv.weight" -> "734 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"734 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "735 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0"; +"735 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/Conv2d[conv]/conv2d_0" -> "738 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"736 Mixed_7c.branch1x1.bn.weight" -> "738 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"737 Mixed_7c.branch1x1.bn.bias" -> "738 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0"; +"738 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm_0" -> "739 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/relu__0"; +"739 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/relu__0" -> "740 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"740 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "809 Inception3/InceptionE[Mixed_7c]/cat_2"; +"741 Mixed_7c.branch3x3_1.conv.weight" -> "742 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"742 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "743 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0"; +"743 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/Conv2d[conv]/conv2d_0" -> "746 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"744 Mixed_7c.branch3x3_1.bn.weight" -> "746 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"745 Mixed_7c.branch3x3_1.bn.bias" -> "746 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0"; +"746 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm_0" -> "747 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/relu__0"; +"747 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/relu__0" -> "748 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0"; +"748 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "751 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0"; +"748 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/SymmetricQuantizer/symmetric_quantize_0" -> "759 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0"; +"749 Mixed_7c.branch3x3_2a.conv.weight" -> "750 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"750 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "751 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0"; +"751 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/Conv2d[conv]/conv2d_0" -> "754 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0"; +"752 Mixed_7c.branch3x3_2a.bn.weight" -> "754 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0"; +"753 Mixed_7c.branch3x3_2a.bn.bias" -> "754 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0"; +"754 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm_0" -> "755 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/relu__0"; +"755 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/relu__0" -> "756 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0"; +"756 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize_0" -> "765 Inception3/InceptionE[Mixed_7c]/cat_0"; +"757 Mixed_7c.branch3x3_2b.conv.weight" -> "758 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"758 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "759 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0"; +"759 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/Conv2d[conv]/conv2d_0" -> "762 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0"; +"760 Mixed_7c.branch3x3_2b.bn.weight" -> "762 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0"; +"761 Mixed_7c.branch3x3_2b.bn.bias" -> "762 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0"; +"762 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm_0" -> "763 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/relu__0"; +"763 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/relu__0" -> "764 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0"; +"764 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize_0" -> "765 Inception3/InceptionE[Mixed_7c]/cat_0"; +"765 Inception3/InceptionE[Mixed_7c]/cat_0" -> "809 Inception3/InceptionE[Mixed_7c]/cat_2"; +"766 Mixed_7c.branch3x3dbl_1.conv.weight" -> "767 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"767 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "768 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0"; +"768 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/Conv2d[conv]/conv2d_0" -> "771 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"769 Mixed_7c.branch3x3dbl_1.bn.weight" -> "771 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"770 Mixed_7c.branch3x3dbl_1.bn.bias" -> "771 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0"; +"771 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm_0" -> "772 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/relu__0"; +"772 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/relu__0" -> "773 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0"; +"773 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/SymmetricQuantizer/symmetric_quantize_0" -> "776 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"774 Mixed_7c.branch3x3dbl_2.conv.weight" -> "775 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"775 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "776 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0"; +"776 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/Conv2d[conv]/conv2d_0" -> "779 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"777 Mixed_7c.branch3x3dbl_2.bn.weight" -> "779 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"778 Mixed_7c.branch3x3dbl_2.bn.bias" -> "779 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0"; +"779 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm_0" -> "780 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/relu__0"; +"780 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/relu__0" -> "781 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0"; +"781 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "784 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0"; +"781 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/SymmetricQuantizer/symmetric_quantize_0" -> "792 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0"; +"782 Mixed_7c.branch3x3dbl_3a.conv.weight" -> "783 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"783 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "784 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0"; +"784 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/Conv2d[conv]/conv2d_0" -> "787 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0"; +"785 Mixed_7c.branch3x3dbl_3a.bn.weight" -> "787 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0"; +"786 Mixed_7c.branch3x3dbl_3a.bn.bias" -> "787 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0"; +"787 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm_0" -> "788 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/relu__0"; +"788 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/relu__0" -> "789 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0"; +"789 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize_0" -> "798 Inception3/InceptionE[Mixed_7c]/cat_1"; +"790 Mixed_7c.branch3x3dbl_3b.conv.weight" -> "791 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"791 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "792 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0"; +"792 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/Conv2d[conv]/conv2d_0" -> "795 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0"; +"793 Mixed_7c.branch3x3dbl_3b.bn.weight" -> "795 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0"; +"794 Mixed_7c.branch3x3dbl_3b.bn.bias" -> "795 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0"; +"795 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm_0" -> "796 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/relu__0"; +"796 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/relu__0" -> "797 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0"; +"797 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize_0" -> "798 Inception3/InceptionE[Mixed_7c]/cat_1"; +"798 Inception3/InceptionE[Mixed_7c]/cat_1" -> "809 Inception3/InceptionE[Mixed_7c]/cat_2"; +"799 Inception3/InceptionE[Mixed_7c]/avg_pool2d_0" -> "800 Inception3/InceptionE[Mixed_7c]/SymmetricQuantizer/symmetric_quantize_0"; +"800 Inception3/InceptionE[Mixed_7c]/SymmetricQuantizer/symmetric_quantize_0" -> "803 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"801 Mixed_7c.branch_pool.conv.weight" -> "802 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"802 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "803 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0"; +"803 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/Conv2d[conv]/conv2d_0" -> "806 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"804 Mixed_7c.branch_pool.bn.weight" -> "806 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"805 Mixed_7c.branch_pool.bn.bias" -> "806 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0"; +"806 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm_0" -> "807 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/relu__0"; +"807 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/relu__0" -> "808 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0"; +"808 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize_0" -> "809 Inception3/InceptionE[Mixed_7c]/cat_2"; +"809 Inception3/InceptionE[Mixed_7c]/cat_2" -> "810 Inception3/adaptive_avg_pool2d_0"; +"810 Inception3/adaptive_avg_pool2d_0" -> "811 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; +"811 Inception3/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[Inception3/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "812 Inception3/dropout_0"; +"812 Inception3/dropout_0" -> "813 Inception3/view_0"; +"813 Inception3/view_0" -> "817 Inception3/Linear[fc]/linear_0"; +"814 fc.weight" -> "816 Inception3/Linear[fc]/SymmetricQuantizer/symmetric_quantize_0"; +"815 fc.bias" -> "817 Inception3/Linear[fc]/linear_0"; +"816 Inception3/Linear[fc]/SymmetricQuantizer/symmetric_quantize_0" -> "817 Inception3/Linear[fc]/linear_0"; +"817 Inception3/Linear[fc]/linear_0" -> "818 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/lenet.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/lenet.dot index b5246ce1849..289227935f2 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/lenet.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/lenet.dot @@ -1,49 +1,69 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 LeNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 LeNet/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; -"4 LeNet/relu_0" [id=4, type=relu]; -"5 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=5, type=symmetric_quantize]; -"6 LeNet/max_pool2d_0" [id=6, type=max_pool2d]; -"7 LeNet/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 LeNet/NNCFConv2d[conv2]/conv2d_0" [id=8, type=conv2d]; -"9 LeNet/relu_1" [id=9, type=relu]; -"10 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_1|OUTPUT]/symmetric_quantize_0" [id=10, type=symmetric_quantize]; -"11 LeNet/max_pool2d_1" [id=11, type=max_pool2d]; -"12 LeNet/view_0" [id=12, type=view]; -"13 LeNet/NNCFLinear[fc1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; -"14 LeNet/NNCFLinear[fc1]/linear_0" [id=14, type=linear]; -"15 LeNet/relu_2" [id=15, type=relu]; -"16 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_2|OUTPUT]/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 LeNet/NNCFLinear[fc2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=17, type=symmetric_quantize]; -"18 LeNet/NNCFLinear[fc2]/linear_0" [id=18, type=linear]; -"19 LeNet/relu_3" [id=19, type=relu]; -"20 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_3|OUTPUT]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 LeNet/NNCFLinear[fc3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 LeNet/NNCFLinear[fc3]/linear_0" [id=22, type=linear]; -"23 /nncf_model_output_0" [id=23, type=nncf_model_output]; +"2 conv1.weight" [id=2, type=nncf_model_const]; +"3 conv1.bias" [id=3, type=nncf_model_const]; +"4 LeNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 LeNet/Conv2d[conv1]/conv2d_0" [id=5, type=conv2d]; +"6 LeNet/relu_0" [id=6, type=relu]; +"7 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 LeNet/max_pool2d_0" [id=8, type=max_pool2d]; +"9 conv2.weight" [id=9, type=nncf_model_const]; +"10 conv2.bias" [id=10, type=nncf_model_const]; +"11 LeNet/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 LeNet/Conv2d[conv2]/conv2d_0" [id=12, type=conv2d]; +"13 LeNet/relu_1" [id=13, type=relu]; +"14 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_1|OUTPUT]/symmetric_quantize_0" [id=14, type=symmetric_quantize]; +"15 LeNet/max_pool2d_1" [id=15, type=max_pool2d]; +"16 LeNet/view_0" [id=16, type=view]; +"17 fc1.weight" [id=17, type=nncf_model_const]; +"18 fc1.bias" [id=18, type=nncf_model_const]; +"19 LeNet/Linear[fc1]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; +"20 LeNet/Linear[fc1]/linear_0" [id=20, type=linear]; +"21 LeNet/relu_2" [id=21, type=relu]; +"22 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_2|OUTPUT]/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 fc2.weight" [id=23, type=nncf_model_const]; +"24 fc2.bias" [id=24, type=nncf_model_const]; +"25 LeNet/Linear[fc2]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 LeNet/Linear[fc2]/linear_0" [id=26, type=linear]; +"27 LeNet/relu_3" [id=27, type=relu]; +"28 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_3|OUTPUT]/symmetric_quantize_0" [id=28, type=symmetric_quantize]; +"29 fc3.weight" [id=29, type=nncf_model_const]; +"30 fc3.bias" [id=30, type=nncf_model_const]; +"31 LeNet/Linear[fc3]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; +"32 LeNet/Linear[fc3]/linear_0" [id=32, type=linear]; +"33 /nncf_model_output_0" [id=33, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 LeNet/NNCFConv2d[conv1]/conv2d_0"; -"2 LeNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 LeNet/NNCFConv2d[conv1]/conv2d_0"; -"3 LeNet/NNCFConv2d[conv1]/conv2d_0" -> "4 LeNet/relu_0"; -"4 LeNet/relu_0" -> "5 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_0|OUTPUT]/symmetric_quantize_0"; -"5 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "6 LeNet/max_pool2d_0"; -"6 LeNet/max_pool2d_0" -> "8 LeNet/NNCFConv2d[conv2]/conv2d_0"; -"7 LeNet/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 LeNet/NNCFConv2d[conv2]/conv2d_0"; -"8 LeNet/NNCFConv2d[conv2]/conv2d_0" -> "9 LeNet/relu_1"; -"9 LeNet/relu_1" -> "10 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_1|OUTPUT]/symmetric_quantize_0"; -"10 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_1|OUTPUT]/symmetric_quantize_0" -> "11 LeNet/max_pool2d_1"; -"11 LeNet/max_pool2d_1" -> "12 LeNet/view_0"; -"12 LeNet/view_0" -> "14 LeNet/NNCFLinear[fc1]/linear_0"; -"13 LeNet/NNCFLinear[fc1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 LeNet/NNCFLinear[fc1]/linear_0"; -"14 LeNet/NNCFLinear[fc1]/linear_0" -> "15 LeNet/relu_2"; -"15 LeNet/relu_2" -> "16 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_2|OUTPUT]/symmetric_quantize_0"; -"16 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_2|OUTPUT]/symmetric_quantize_0" -> "18 LeNet/NNCFLinear[fc2]/linear_0"; -"17 LeNet/NNCFLinear[fc2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "18 LeNet/NNCFLinear[fc2]/linear_0"; -"18 LeNet/NNCFLinear[fc2]/linear_0" -> "19 LeNet/relu_3"; -"19 LeNet/relu_3" -> "20 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_3|OUTPUT]/symmetric_quantize_0"; -"20 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_3|OUTPUT]/symmetric_quantize_0" -> "22 LeNet/NNCFLinear[fc3]/linear_0"; -"21 LeNet/NNCFLinear[fc3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 LeNet/NNCFLinear[fc3]/linear_0"; -"22 LeNet/NNCFLinear[fc3]/linear_0" -> "23 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 LeNet/Conv2d[conv1]/conv2d_0"; +"2 conv1.weight" -> "4 LeNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"3 conv1.bias" -> "5 LeNet/Conv2d[conv1]/conv2d_0"; +"4 LeNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "5 LeNet/Conv2d[conv1]/conv2d_0"; +"5 LeNet/Conv2d[conv1]/conv2d_0" -> "6 LeNet/relu_0"; +"6 LeNet/relu_0" -> "7 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_0|OUTPUT]/symmetric_quantize_0"; +"7 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "8 LeNet/max_pool2d_0"; +"8 LeNet/max_pool2d_0" -> "12 LeNet/Conv2d[conv2]/conv2d_0"; +"9 conv2.weight" -> "11 LeNet/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"10 conv2.bias" -> "12 LeNet/Conv2d[conv2]/conv2d_0"; +"11 LeNet/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "12 LeNet/Conv2d[conv2]/conv2d_0"; +"12 LeNet/Conv2d[conv2]/conv2d_0" -> "13 LeNet/relu_1"; +"13 LeNet/relu_1" -> "14 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_1|OUTPUT]/symmetric_quantize_0"; +"14 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_1|OUTPUT]/symmetric_quantize_0" -> "15 LeNet/max_pool2d_1"; +"15 LeNet/max_pool2d_1" -> "16 LeNet/view_0"; +"16 LeNet/view_0" -> "20 LeNet/Linear[fc1]/linear_0"; +"17 fc1.weight" -> "19 LeNet/Linear[fc1]/SymmetricQuantizer/symmetric_quantize_0"; +"18 fc1.bias" -> "20 LeNet/Linear[fc1]/linear_0"; +"19 LeNet/Linear[fc1]/SymmetricQuantizer/symmetric_quantize_0" -> "20 LeNet/Linear[fc1]/linear_0"; +"20 LeNet/Linear[fc1]/linear_0" -> "21 LeNet/relu_2"; +"21 LeNet/relu_2" -> "22 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_2|OUTPUT]/symmetric_quantize_0"; +"22 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_2|OUTPUT]/symmetric_quantize_0" -> "26 LeNet/Linear[fc2]/linear_0"; +"23 fc2.weight" -> "25 LeNet/Linear[fc2]/SymmetricQuantizer/symmetric_quantize_0"; +"24 fc2.bias" -> "26 LeNet/Linear[fc2]/linear_0"; +"25 LeNet/Linear[fc2]/SymmetricQuantizer/symmetric_quantize_0" -> "26 LeNet/Linear[fc2]/linear_0"; +"26 LeNet/Linear[fc2]/linear_0" -> "27 LeNet/relu_3"; +"27 LeNet/relu_3" -> "28 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_3|OUTPUT]/symmetric_quantize_0"; +"28 LeNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[LeNet/relu_3|OUTPUT]/symmetric_quantize_0" -> "32 LeNet/Linear[fc3]/linear_0"; +"29 fc3.weight" -> "31 LeNet/Linear[fc3]/SymmetricQuantizer/symmetric_quantize_0"; +"30 fc3.bias" -> "32 LeNet/Linear[fc3]/linear_0"; +"31 LeNet/Linear[fc3]/SymmetricQuantizer/symmetric_quantize_0" -> "32 LeNet/Linear[fc3]/linear_0"; +"32 LeNet/Linear[fc3]/linear_0" -> "33 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v2.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v2.dot index 853585f0f8f..fb42bd4a4d5 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v2.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v2.dot @@ -1,555 +1,871 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=4, type=batch_norm]; -"5 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=5, type=hardtanh]; -"6 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=8, type=conv2d]; -"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=9, type=batch_norm]; -"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=10, type=hardtanh]; -"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=12, type=symmetric_quantize]; -"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d_0" [id=13, type=conv2d]; -"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFBatchNorm2d[2]/batch_norm_0" [id=14, type=batch_norm]; -"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFBatchNorm2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=15, type=symmetric_quantize]; -"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=17, type=conv2d]; -"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=18, type=batch_norm]; -"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=19, type=hardtanh]; -"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=22, type=conv2d]; -"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=23, type=batch_norm]; -"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=24, type=hardtanh]; -"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=26, type=symmetric_quantize]; -"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=27, type=conv2d]; -"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=28, type=batch_norm]; -"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=29, type=symmetric_quantize]; -"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=30, type=symmetric_quantize]; -"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=31, type=conv2d]; -"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=32, type=batch_norm]; -"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=33, type=hardtanh]; -"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; -"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=35, type=symmetric_quantize]; -"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=36, type=conv2d]; -"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=37, type=batch_norm]; -"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=38, type=hardtanh]; -"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; -"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=40, type=symmetric_quantize]; -"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=41, type=conv2d]; -"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=42, type=batch_norm]; -"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=43, type=symmetric_quantize]; -"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0" [id=44, type=__add__]; -"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" [id=45, type=symmetric_quantize]; -"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=46, type=symmetric_quantize]; -"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=47, type=conv2d]; -"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=48, type=batch_norm]; -"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=49, type=hardtanh]; -"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; -"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; -"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=52, type=conv2d]; -"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=53, type=batch_norm]; -"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=54, type=hardtanh]; -"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; -"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; -"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=57, type=conv2d]; -"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=58, type=batch_norm]; -"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=59, type=symmetric_quantize]; -"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=60, type=symmetric_quantize]; -"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=61, type=conv2d]; -"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=62, type=batch_norm]; -"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=63, type=hardtanh]; -"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=66, type=conv2d]; -"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=67, type=batch_norm]; -"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=68, type=hardtanh]; -"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=70, type=symmetric_quantize]; -"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=71, type=conv2d]; -"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=72, type=batch_norm]; -"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0" [id=74, type=__add__]; -"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=76, type=symmetric_quantize]; -"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=77, type=conv2d]; -"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=78, type=batch_norm]; -"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=79, type=hardtanh]; -"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; -"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=82, type=conv2d]; -"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=83, type=batch_norm]; -"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=84, type=hardtanh]; -"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=86, type=symmetric_quantize]; -"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=87, type=conv2d]; -"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=88, type=batch_norm]; -"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=89, type=symmetric_quantize]; -"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0" [id=90, type=__add__]; -"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=92, type=symmetric_quantize]; -"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=93, type=conv2d]; -"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=94, type=batch_norm]; -"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=95, type=hardtanh]; -"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=97, type=symmetric_quantize]; -"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=98, type=conv2d]; -"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=99, type=batch_norm]; -"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=100, type=hardtanh]; -"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; -"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=102, type=symmetric_quantize]; -"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=103, type=conv2d]; -"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=104, type=batch_norm]; -"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; -"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=106, type=symmetric_quantize]; -"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=107, type=conv2d]; -"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=108, type=batch_norm]; -"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=109, type=hardtanh]; -"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; -"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=112, type=conv2d]; -"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=113, type=batch_norm]; -"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=114, type=hardtanh]; -"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=115, type=symmetric_quantize]; -"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=116, type=symmetric_quantize]; -"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=117, type=conv2d]; -"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=118, type=batch_norm]; -"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=119, type=symmetric_quantize]; -"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0" [id=120, type=__add__]; -"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" [id=121, type=symmetric_quantize]; -"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=122, type=symmetric_quantize]; -"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=123, type=conv2d]; -"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=124, type=batch_norm]; -"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=125, type=hardtanh]; -"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; -"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=127, type=symmetric_quantize]; -"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=128, type=conv2d]; -"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=129, type=batch_norm]; -"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=130, type=hardtanh]; -"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; -"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=132, type=symmetric_quantize]; -"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=133, type=conv2d]; -"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=134, type=batch_norm]; -"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=135, type=symmetric_quantize]; -"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0" [id=136, type=__add__]; -"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0" [id=137, type=symmetric_quantize]; -"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=138, type=symmetric_quantize]; -"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=139, type=conv2d]; -"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=140, type=batch_norm]; -"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=141, type=hardtanh]; -"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; -"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=143, type=symmetric_quantize]; -"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=144, type=conv2d]; -"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=145, type=batch_norm]; -"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=146, type=hardtanh]; -"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; -"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=149, type=conv2d]; -"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=150, type=batch_norm]; -"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=151, type=symmetric_quantize]; -"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0" [id=152, type=__add__]; -"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" [id=153, type=symmetric_quantize]; -"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=154, type=symmetric_quantize]; -"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=155, type=conv2d]; -"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=156, type=batch_norm]; -"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=157, type=hardtanh]; -"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=158, type=symmetric_quantize]; -"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=159, type=symmetric_quantize]; -"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=160, type=conv2d]; -"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=161, type=batch_norm]; -"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=162, type=hardtanh]; -"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=163, type=symmetric_quantize]; -"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=164, type=symmetric_quantize]; -"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=165, type=conv2d]; -"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=166, type=batch_norm]; -"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; -"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=168, type=symmetric_quantize]; -"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=169, type=conv2d]; -"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=170, type=batch_norm]; -"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=171, type=hardtanh]; -"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=172, type=symmetric_quantize]; -"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=173, type=symmetric_quantize]; -"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=174, type=conv2d]; -"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=175, type=batch_norm]; -"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=176, type=hardtanh]; -"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; -"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=178, type=symmetric_quantize]; -"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=179, type=conv2d]; -"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=180, type=batch_norm]; -"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=181, type=symmetric_quantize]; -"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0" [id=182, type=__add__]; -"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0" [id=183, type=symmetric_quantize]; -"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=184, type=symmetric_quantize]; -"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=185, type=conv2d]; -"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=186, type=batch_norm]; -"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=187, type=hardtanh]; -"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; -"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=189, type=symmetric_quantize]; -"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=190, type=conv2d]; -"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=191, type=batch_norm]; -"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=192, type=hardtanh]; -"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; -"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=194, type=symmetric_quantize]; -"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=195, type=conv2d]; -"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=196, type=batch_norm]; -"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=197, type=symmetric_quantize]; -"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0" [id=198, type=__add__]; -"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/SymmetricQuantizer/symmetric_quantize_0" [id=199, type=symmetric_quantize]; -"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=200, type=symmetric_quantize]; -"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=201, type=conv2d]; -"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=202, type=batch_norm]; -"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=203, type=hardtanh]; -"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=204, type=symmetric_quantize]; -"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=205, type=symmetric_quantize]; -"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=206, type=conv2d]; -"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=207, type=batch_norm]; -"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=208, type=hardtanh]; -"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; -"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=210, type=symmetric_quantize]; -"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=211, type=conv2d]; -"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=212, type=batch_norm]; -"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=213, type=symmetric_quantize]; -"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=214, type=symmetric_quantize]; -"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=215, type=conv2d]; -"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=216, type=batch_norm]; -"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=217, type=hardtanh]; -"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=218, type=symmetric_quantize]; -"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=219, type=symmetric_quantize]; -"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=220, type=conv2d]; -"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=221, type=batch_norm]; -"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=222, type=hardtanh]; -"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; -"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; -"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=225, type=conv2d]; -"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=226, type=batch_norm]; -"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=227, type=symmetric_quantize]; -"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0" [id=228, type=__add__]; -"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0" [id=229, type=symmetric_quantize]; -"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=230, type=symmetric_quantize]; -"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=231, type=conv2d]; -"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=232, type=batch_norm]; -"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=233, type=hardtanh]; -"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; -"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=235, type=symmetric_quantize]; -"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=236, type=conv2d]; -"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=237, type=batch_norm]; -"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=238, type=hardtanh]; -"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; -"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=240, type=symmetric_quantize]; -"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=241, type=conv2d]; -"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=242, type=batch_norm]; -"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=243, type=symmetric_quantize]; -"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0" [id=244, type=__add__]; -"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/SymmetricQuantizer/symmetric_quantize_0" [id=245, type=symmetric_quantize]; -"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=246, type=symmetric_quantize]; -"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=247, type=conv2d]; -"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=248, type=batch_norm]; -"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=249, type=hardtanh]; -"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=250, type=symmetric_quantize]; -"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=251, type=symmetric_quantize]; -"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=252, type=conv2d]; -"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=253, type=batch_norm]; -"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=254, type=hardtanh]; -"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; -"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=256, type=symmetric_quantize]; -"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" [id=257, type=conv2d]; -"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" [id=258, type=batch_norm]; -"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=259, type=symmetric_quantize]; -"260 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=260, type=symmetric_quantize]; -"261 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFConv2d[0]/conv2d_0" [id=261, type=conv2d]; -"262 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFBatchNorm2d[1]/batch_norm_0" [id=262, type=batch_norm]; -"263 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/hardtanh_0" [id=263, type=hardtanh]; -"264 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=264, type=symmetric_quantize]; -"265 MobileNetV2/adaptive_avg_pool2d_0" [id=265, type=adaptive_avg_pool2d]; -"266 MobileNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[MobileNetV2/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=266, type=symmetric_quantize]; -"267 MobileNetV2/reshape_0" [id=267, type=reshape]; -"268 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout_0" [id=268, type=dropout]; -"269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=269, type=symmetric_quantize]; -"270 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear_0" [id=270, type=linear]; -"271 /nncf_model_output_0" [id=271, type=nncf_model_output]; +"2 features.0.0.weight" [id=2, type=nncf_model_const]; +"3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=4, type=conv2d]; +"5 features.0.1.weight" [id=5, type=nncf_model_const]; +"6 features.0.1.bias" [id=6, type=nncf_model_const]; +"7 MobileNetV2/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=7, type=batch_norm]; +"8 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=8, type=hardtanh]; +"9 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=9, type=symmetric_quantize]; +"10 features.1.conv.0.0.weight" [id=10, type=nncf_model_const]; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=12, type=conv2d]; +"13 features.1.conv.0.1.weight" [id=13, type=nncf_model_const]; +"14 features.1.conv.0.1.bias" [id=14, type=nncf_model_const]; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=15, type=batch_norm]; +"16 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=16, type=hardtanh]; +"17 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=17, type=symmetric_quantize]; +"18 features.1.conv.1.weight" [id=18, type=nncf_model_const]; +"19 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; +"20 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/conv2d_0" [id=20, type=conv2d]; +"21 features.1.conv.2.weight" [id=21, type=nncf_model_const]; +"22 features.1.conv.2.bias" [id=22, type=nncf_model_const]; +"23 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm_0" [id=23, type=batch_norm]; +"24 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; +"25 features.2.conv.0.0.weight" [id=25, type=nncf_model_const]; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=27, type=conv2d]; +"28 features.2.conv.0.1.weight" [id=28, type=nncf_model_const]; +"29 features.2.conv.0.1.bias" [id=29, type=nncf_model_const]; +"30 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=30, type=batch_norm]; +"31 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=31, type=hardtanh]; +"32 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=32, type=symmetric_quantize]; +"33 features.2.conv.1.0.weight" [id=33, type=nncf_model_const]; +"34 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=35, type=conv2d]; +"36 features.2.conv.1.1.weight" [id=36, type=nncf_model_const]; +"37 features.2.conv.1.1.bias" [id=37, type=nncf_model_const]; +"38 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=38, type=batch_norm]; +"39 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=39, type=hardtanh]; +"40 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=40, type=symmetric_quantize]; +"41 features.2.conv.2.weight" [id=41, type=nncf_model_const]; +"42 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=43, type=conv2d]; +"44 features.2.conv.3.weight" [id=44, type=nncf_model_const]; +"45 features.2.conv.3.bias" [id=45, type=nncf_model_const]; +"46 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=46, type=batch_norm]; +"47 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=47, type=symmetric_quantize]; +"48 features.3.conv.0.0.weight" [id=48, type=nncf_model_const]; +"49 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=49, type=symmetric_quantize]; +"50 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=50, type=conv2d]; +"51 features.3.conv.0.1.weight" [id=51, type=nncf_model_const]; +"52 features.3.conv.0.1.bias" [id=52, type=nncf_model_const]; +"53 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=53, type=batch_norm]; +"54 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=54, type=hardtanh]; +"55 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; +"56 features.3.conv.1.0.weight" [id=56, type=nncf_model_const]; +"57 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=57, type=symmetric_quantize]; +"58 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=58, type=conv2d]; +"59 features.3.conv.1.1.weight" [id=59, type=nncf_model_const]; +"60 features.3.conv.1.1.bias" [id=60, type=nncf_model_const]; +"61 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=61, type=batch_norm]; +"62 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=62, type=hardtanh]; +"63 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; +"64 features.3.conv.2.weight" [id=64, type=nncf_model_const]; +"65 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=65, type=symmetric_quantize]; +"66 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=66, type=conv2d]; +"67 features.3.conv.3.weight" [id=67, type=nncf_model_const]; +"68 features.3.conv.3.bias" [id=68, type=nncf_model_const]; +"69 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=69, type=batch_norm]; +"70 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0" [id=71, type=__add__]; +"72 MobileNetV2/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" [id=72, type=symmetric_quantize]; +"73 features.4.conv.0.0.weight" [id=73, type=nncf_model_const]; +"74 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; +"75 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=75, type=conv2d]; +"76 features.4.conv.0.1.weight" [id=76, type=nncf_model_const]; +"77 features.4.conv.0.1.bias" [id=77, type=nncf_model_const]; +"78 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=78, type=batch_norm]; +"79 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=79, type=hardtanh]; +"80 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 features.4.conv.1.0.weight" [id=81, type=nncf_model_const]; +"82 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=82, type=symmetric_quantize]; +"83 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=83, type=conv2d]; +"84 features.4.conv.1.1.weight" [id=84, type=nncf_model_const]; +"85 features.4.conv.1.1.bias" [id=85, type=nncf_model_const]; +"86 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=86, type=batch_norm]; +"87 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=87, type=hardtanh]; +"88 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; +"89 features.4.conv.2.weight" [id=89, type=nncf_model_const]; +"90 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=90, type=symmetric_quantize]; +"91 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=91, type=conv2d]; +"92 features.4.conv.3.weight" [id=92, type=nncf_model_const]; +"93 features.4.conv.3.bias" [id=93, type=nncf_model_const]; +"94 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=94, type=batch_norm]; +"95 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=95, type=symmetric_quantize]; +"96 features.5.conv.0.0.weight" [id=96, type=nncf_model_const]; +"97 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=98, type=conv2d]; +"99 features.5.conv.0.1.weight" [id=99, type=nncf_model_const]; +"100 features.5.conv.0.1.bias" [id=100, type=nncf_model_const]; +"101 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=101, type=batch_norm]; +"102 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=102, type=hardtanh]; +"103 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=103, type=symmetric_quantize]; +"104 features.5.conv.1.0.weight" [id=104, type=nncf_model_const]; +"105 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; +"106 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=106, type=conv2d]; +"107 features.5.conv.1.1.weight" [id=107, type=nncf_model_const]; +"108 features.5.conv.1.1.bias" [id=108, type=nncf_model_const]; +"109 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=109, type=batch_norm]; +"110 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=110, type=hardtanh]; +"111 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 features.5.conv.2.weight" [id=112, type=nncf_model_const]; +"113 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=113, type=symmetric_quantize]; +"114 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=114, type=conv2d]; +"115 features.5.conv.3.weight" [id=115, type=nncf_model_const]; +"116 features.5.conv.3.bias" [id=116, type=nncf_model_const]; +"117 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=117, type=batch_norm]; +"118 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=118, type=symmetric_quantize]; +"119 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0" [id=119, type=__add__]; +"120 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 features.6.conv.0.0.weight" [id=121, type=nncf_model_const]; +"122 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; +"123 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=123, type=conv2d]; +"124 features.6.conv.0.1.weight" [id=124, type=nncf_model_const]; +"125 features.6.conv.0.1.bias" [id=125, type=nncf_model_const]; +"126 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=126, type=batch_norm]; +"127 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=127, type=hardtanh]; +"128 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=128, type=symmetric_quantize]; +"129 features.6.conv.1.0.weight" [id=129, type=nncf_model_const]; +"130 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=130, type=symmetric_quantize]; +"131 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=131, type=conv2d]; +"132 features.6.conv.1.1.weight" [id=132, type=nncf_model_const]; +"133 features.6.conv.1.1.bias" [id=133, type=nncf_model_const]; +"134 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=134, type=batch_norm]; +"135 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=135, type=hardtanh]; +"136 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=136, type=symmetric_quantize]; +"137 features.6.conv.2.weight" [id=137, type=nncf_model_const]; +"138 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=138, type=symmetric_quantize]; +"139 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=139, type=conv2d]; +"140 features.6.conv.3.weight" [id=140, type=nncf_model_const]; +"141 features.6.conv.3.bias" [id=141, type=nncf_model_const]; +"142 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=142, type=batch_norm]; +"143 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=143, type=symmetric_quantize]; +"144 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0" [id=144, type=__add__]; +"145 MobileNetV2/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 features.7.conv.0.0.weight" [id=146, type=nncf_model_const]; +"147 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=148, type=conv2d]; +"149 features.7.conv.0.1.weight" [id=149, type=nncf_model_const]; +"150 features.7.conv.0.1.bias" [id=150, type=nncf_model_const]; +"151 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=151, type=batch_norm]; +"152 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=152, type=hardtanh]; +"153 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=153, type=symmetric_quantize]; +"154 features.7.conv.1.0.weight" [id=154, type=nncf_model_const]; +"155 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; +"156 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=156, type=conv2d]; +"157 features.7.conv.1.1.weight" [id=157, type=nncf_model_const]; +"158 features.7.conv.1.1.bias" [id=158, type=nncf_model_const]; +"159 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=159, type=batch_norm]; +"160 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=160, type=hardtanh]; +"161 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 features.7.conv.2.weight" [id=162, type=nncf_model_const]; +"163 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=163, type=symmetric_quantize]; +"164 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=164, type=conv2d]; +"165 features.7.conv.3.weight" [id=165, type=nncf_model_const]; +"166 features.7.conv.3.bias" [id=166, type=nncf_model_const]; +"167 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=167, type=batch_norm]; +"168 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=168, type=symmetric_quantize]; +"169 features.8.conv.0.0.weight" [id=169, type=nncf_model_const]; +"170 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=170, type=symmetric_quantize]; +"171 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=171, type=conv2d]; +"172 features.8.conv.0.1.weight" [id=172, type=nncf_model_const]; +"173 features.8.conv.0.1.bias" [id=173, type=nncf_model_const]; +"174 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=174, type=batch_norm]; +"175 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=175, type=hardtanh]; +"176 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=176, type=symmetric_quantize]; +"177 features.8.conv.1.0.weight" [id=177, type=nncf_model_const]; +"178 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=178, type=symmetric_quantize]; +"179 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=179, type=conv2d]; +"180 features.8.conv.1.1.weight" [id=180, type=nncf_model_const]; +"181 features.8.conv.1.1.bias" [id=181, type=nncf_model_const]; +"182 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=182, type=batch_norm]; +"183 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=183, type=hardtanh]; +"184 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=184, type=symmetric_quantize]; +"185 features.8.conv.2.weight" [id=185, type=nncf_model_const]; +"186 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=187, type=conv2d]; +"188 features.8.conv.3.weight" [id=188, type=nncf_model_const]; +"189 features.8.conv.3.bias" [id=189, type=nncf_model_const]; +"190 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=190, type=batch_norm]; +"191 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=191, type=symmetric_quantize]; +"192 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0" [id=192, type=__add__]; +"193 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; +"194 features.9.conv.0.0.weight" [id=194, type=nncf_model_const]; +"195 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=196, type=conv2d]; +"197 features.9.conv.0.1.weight" [id=197, type=nncf_model_const]; +"198 features.9.conv.0.1.bias" [id=198, type=nncf_model_const]; +"199 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=199, type=batch_norm]; +"200 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=200, type=hardtanh]; +"201 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=201, type=symmetric_quantize]; +"202 features.9.conv.1.0.weight" [id=202, type=nncf_model_const]; +"203 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; +"204 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=204, type=conv2d]; +"205 features.9.conv.1.1.weight" [id=205, type=nncf_model_const]; +"206 features.9.conv.1.1.bias" [id=206, type=nncf_model_const]; +"207 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=207, type=batch_norm]; +"208 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=208, type=hardtanh]; +"209 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; +"210 features.9.conv.2.weight" [id=210, type=nncf_model_const]; +"211 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=211, type=symmetric_quantize]; +"212 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=212, type=conv2d]; +"213 features.9.conv.3.weight" [id=213, type=nncf_model_const]; +"214 features.9.conv.3.bias" [id=214, type=nncf_model_const]; +"215 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=215, type=batch_norm]; +"216 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=216, type=symmetric_quantize]; +"217 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0" [id=217, type=__add__]; +"218 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0" [id=218, type=symmetric_quantize]; +"219 features.10.conv.0.0.weight" [id=219, type=nncf_model_const]; +"220 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=220, type=symmetric_quantize]; +"221 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=221, type=conv2d]; +"222 features.10.conv.0.1.weight" [id=222, type=nncf_model_const]; +"223 features.10.conv.0.1.bias" [id=223, type=nncf_model_const]; +"224 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=224, type=batch_norm]; +"225 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=225, type=hardtanh]; +"226 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=226, type=symmetric_quantize]; +"227 features.10.conv.1.0.weight" [id=227, type=nncf_model_const]; +"228 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=229, type=conv2d]; +"230 features.10.conv.1.1.weight" [id=230, type=nncf_model_const]; +"231 features.10.conv.1.1.bias" [id=231, type=nncf_model_const]; +"232 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=232, type=batch_norm]; +"233 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=233, type=hardtanh]; +"234 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 features.10.conv.2.weight" [id=235, type=nncf_model_const]; +"236 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=236, type=symmetric_quantize]; +"237 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=237, type=conv2d]; +"238 features.10.conv.3.weight" [id=238, type=nncf_model_const]; +"239 features.10.conv.3.bias" [id=239, type=nncf_model_const]; +"240 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=240, type=batch_norm]; +"241 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0" [id=242, type=__add__]; +"243 MobileNetV2/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" [id=243, type=symmetric_quantize]; +"244 features.11.conv.0.0.weight" [id=244, type=nncf_model_const]; +"245 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=245, type=symmetric_quantize]; +"246 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=246, type=conv2d]; +"247 features.11.conv.0.1.weight" [id=247, type=nncf_model_const]; +"248 features.11.conv.0.1.bias" [id=248, type=nncf_model_const]; +"249 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=249, type=batch_norm]; +"250 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=250, type=hardtanh]; +"251 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 features.11.conv.1.0.weight" [id=252, type=nncf_model_const]; +"253 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=253, type=symmetric_quantize]; +"254 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=254, type=conv2d]; +"255 features.11.conv.1.1.weight" [id=255, type=nncf_model_const]; +"256 features.11.conv.1.1.bias" [id=256, type=nncf_model_const]; +"257 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=257, type=batch_norm]; +"258 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=258, type=hardtanh]; +"259 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=259, type=symmetric_quantize]; +"260 features.11.conv.2.weight" [id=260, type=nncf_model_const]; +"261 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=261, type=symmetric_quantize]; +"262 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=262, type=conv2d]; +"263 features.11.conv.3.weight" [id=263, type=nncf_model_const]; +"264 features.11.conv.3.bias" [id=264, type=nncf_model_const]; +"265 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=265, type=batch_norm]; +"266 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=266, type=symmetric_quantize]; +"267 features.12.conv.0.0.weight" [id=267, type=nncf_model_const]; +"268 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=268, type=symmetric_quantize]; +"269 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=269, type=conv2d]; +"270 features.12.conv.0.1.weight" [id=270, type=nncf_model_const]; +"271 features.12.conv.0.1.bias" [id=271, type=nncf_model_const]; +"272 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=272, type=batch_norm]; +"273 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=273, type=hardtanh]; +"274 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=274, type=symmetric_quantize]; +"275 features.12.conv.1.0.weight" [id=275, type=nncf_model_const]; +"276 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=276, type=symmetric_quantize]; +"277 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=277, type=conv2d]; +"278 features.12.conv.1.1.weight" [id=278, type=nncf_model_const]; +"279 features.12.conv.1.1.bias" [id=279, type=nncf_model_const]; +"280 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=280, type=batch_norm]; +"281 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=281, type=hardtanh]; +"282 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=282, type=symmetric_quantize]; +"283 features.12.conv.2.weight" [id=283, type=nncf_model_const]; +"284 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=285, type=conv2d]; +"286 features.12.conv.3.weight" [id=286, type=nncf_model_const]; +"287 features.12.conv.3.bias" [id=287, type=nncf_model_const]; +"288 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=288, type=batch_norm]; +"289 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0" [id=290, type=__add__]; +"291 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 features.13.conv.0.0.weight" [id=292, type=nncf_model_const]; +"293 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=293, type=symmetric_quantize]; +"294 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=294, type=conv2d]; +"295 features.13.conv.0.1.weight" [id=295, type=nncf_model_const]; +"296 features.13.conv.0.1.bias" [id=296, type=nncf_model_const]; +"297 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=297, type=batch_norm]; +"298 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=298, type=hardtanh]; +"299 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=299, type=symmetric_quantize]; +"300 features.13.conv.1.0.weight" [id=300, type=nncf_model_const]; +"301 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=301, type=symmetric_quantize]; +"302 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=302, type=conv2d]; +"303 features.13.conv.1.1.weight" [id=303, type=nncf_model_const]; +"304 features.13.conv.1.1.bias" [id=304, type=nncf_model_const]; +"305 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=305, type=batch_norm]; +"306 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=306, type=hardtanh]; +"307 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=307, type=symmetric_quantize]; +"308 features.13.conv.2.weight" [id=308, type=nncf_model_const]; +"309 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=309, type=symmetric_quantize]; +"310 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=310, type=conv2d]; +"311 features.13.conv.3.weight" [id=311, type=nncf_model_const]; +"312 features.13.conv.3.bias" [id=312, type=nncf_model_const]; +"313 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=313, type=batch_norm]; +"314 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=314, type=symmetric_quantize]; +"315 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0" [id=315, type=__add__]; +"316 MobileNetV2/Sequential[features]/InvertedResidual[13]/SymmetricQuantizer/symmetric_quantize_0" [id=316, type=symmetric_quantize]; +"317 features.14.conv.0.0.weight" [id=317, type=nncf_model_const]; +"318 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=318, type=symmetric_quantize]; +"319 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=319, type=conv2d]; +"320 features.14.conv.0.1.weight" [id=320, type=nncf_model_const]; +"321 features.14.conv.0.1.bias" [id=321, type=nncf_model_const]; +"322 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=322, type=batch_norm]; +"323 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=323, type=hardtanh]; +"324 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=324, type=symmetric_quantize]; +"325 features.14.conv.1.0.weight" [id=325, type=nncf_model_const]; +"326 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=326, type=symmetric_quantize]; +"327 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=327, type=conv2d]; +"328 features.14.conv.1.1.weight" [id=328, type=nncf_model_const]; +"329 features.14.conv.1.1.bias" [id=329, type=nncf_model_const]; +"330 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=330, type=batch_norm]; +"331 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=331, type=hardtanh]; +"332 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=332, type=symmetric_quantize]; +"333 features.14.conv.2.weight" [id=333, type=nncf_model_const]; +"334 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=334, type=symmetric_quantize]; +"335 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=335, type=conv2d]; +"336 features.14.conv.3.weight" [id=336, type=nncf_model_const]; +"337 features.14.conv.3.bias" [id=337, type=nncf_model_const]; +"338 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=338, type=batch_norm]; +"339 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 features.15.conv.0.0.weight" [id=340, type=nncf_model_const]; +"341 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=341, type=symmetric_quantize]; +"342 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=342, type=conv2d]; +"343 features.15.conv.0.1.weight" [id=343, type=nncf_model_const]; +"344 features.15.conv.0.1.bias" [id=344, type=nncf_model_const]; +"345 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=345, type=batch_norm]; +"346 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=346, type=hardtanh]; +"347 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; +"348 features.15.conv.1.0.weight" [id=348, type=nncf_model_const]; +"349 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=349, type=symmetric_quantize]; +"350 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=350, type=conv2d]; +"351 features.15.conv.1.1.weight" [id=351, type=nncf_model_const]; +"352 features.15.conv.1.1.bias" [id=352, type=nncf_model_const]; +"353 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=353, type=batch_norm]; +"354 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=354, type=hardtanh]; +"355 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=355, type=symmetric_quantize]; +"356 features.15.conv.2.weight" [id=356, type=nncf_model_const]; +"357 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=357, type=symmetric_quantize]; +"358 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=358, type=conv2d]; +"359 features.15.conv.3.weight" [id=359, type=nncf_model_const]; +"360 features.15.conv.3.bias" [id=360, type=nncf_model_const]; +"361 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=361, type=batch_norm]; +"362 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=362, type=symmetric_quantize]; +"363 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0" [id=363, type=__add__]; +"364 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0" [id=364, type=symmetric_quantize]; +"365 features.16.conv.0.0.weight" [id=365, type=nncf_model_const]; +"366 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=366, type=symmetric_quantize]; +"367 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=367, type=conv2d]; +"368 features.16.conv.0.1.weight" [id=368, type=nncf_model_const]; +"369 features.16.conv.0.1.bias" [id=369, type=nncf_model_const]; +"370 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=370, type=batch_norm]; +"371 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=371, type=hardtanh]; +"372 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=372, type=symmetric_quantize]; +"373 features.16.conv.1.0.weight" [id=373, type=nncf_model_const]; +"374 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=374, type=symmetric_quantize]; +"375 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=375, type=conv2d]; +"376 features.16.conv.1.1.weight" [id=376, type=nncf_model_const]; +"377 features.16.conv.1.1.bias" [id=377, type=nncf_model_const]; +"378 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=378, type=batch_norm]; +"379 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=379, type=hardtanh]; +"380 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=380, type=symmetric_quantize]; +"381 features.16.conv.2.weight" [id=381, type=nncf_model_const]; +"382 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=382, type=symmetric_quantize]; +"383 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=383, type=conv2d]; +"384 features.16.conv.3.weight" [id=384, type=nncf_model_const]; +"385 features.16.conv.3.bias" [id=385, type=nncf_model_const]; +"386 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=386, type=batch_norm]; +"387 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=387, type=symmetric_quantize]; +"388 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0" [id=388, type=__add__]; +"389 MobileNetV2/Sequential[features]/InvertedResidual[16]/SymmetricQuantizer/symmetric_quantize_0" [id=389, type=symmetric_quantize]; +"390 features.17.conv.0.0.weight" [id=390, type=nncf_model_const]; +"391 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=391, type=symmetric_quantize]; +"392 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=392, type=conv2d]; +"393 features.17.conv.0.1.weight" [id=393, type=nncf_model_const]; +"394 features.17.conv.0.1.bias" [id=394, type=nncf_model_const]; +"395 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=395, type=batch_norm]; +"396 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" [id=396, type=hardtanh]; +"397 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=397, type=symmetric_quantize]; +"398 features.17.conv.1.0.weight" [id=398, type=nncf_model_const]; +"399 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=399, type=symmetric_quantize]; +"400 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=400, type=conv2d]; +"401 features.17.conv.1.1.weight" [id=401, type=nncf_model_const]; +"402 features.17.conv.1.1.bias" [id=402, type=nncf_model_const]; +"403 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=403, type=batch_norm]; +"404 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" [id=404, type=hardtanh]; +"405 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=405, type=symmetric_quantize]; +"406 features.17.conv.2.weight" [id=406, type=nncf_model_const]; +"407 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" [id=407, type=symmetric_quantize]; +"408 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/conv2d_0" [id=408, type=conv2d]; +"409 features.17.conv.3.weight" [id=409, type=nncf_model_const]; +"410 features.17.conv.3.bias" [id=410, type=nncf_model_const]; +"411 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" [id=411, type=batch_norm]; +"412 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=412, type=symmetric_quantize]; +"413 features.18.0.weight" [id=413, type=nncf_model_const]; +"414 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=414, type=symmetric_quantize]; +"415 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/conv2d_0" [id=415, type=conv2d]; +"416 features.18.1.weight" [id=416, type=nncf_model_const]; +"417 features.18.1.bias" [id=417, type=nncf_model_const]; +"418 MobileNetV2/Sequential[features]/ConvBNActivation[18]/BatchNorm2d[1]/batch_norm_0" [id=418, type=batch_norm]; +"419 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/hardtanh_0" [id=419, type=hardtanh]; +"420 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" [id=420, type=symmetric_quantize]; +"421 MobileNetV2/adaptive_avg_pool2d_0" [id=421, type=adaptive_avg_pool2d]; +"422 MobileNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[MobileNetV2/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=422, type=symmetric_quantize]; +"423 MobileNetV2/reshape_0" [id=423, type=reshape]; +"424 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout_0" [id=424, type=dropout]; +"425 classifier.1.weight" [id=425, type=nncf_model_const]; +"426 classifier.1.bias" [id=426, type=nncf_model_const]; +"427 MobileNetV2/Sequential[classifier]/Linear[1]/SymmetricQuantizer/symmetric_quantize_0" [id=427, type=symmetric_quantize]; +"428 MobileNetV2/Sequential[classifier]/Linear[1]/linear_0" [id=428, type=linear]; +"429 /nncf_model_output_0" [id=429, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"2 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "5 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"5 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "6 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"6 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d_0"; -"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d_0"; -"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d_0" -> "14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFBatchNorm2d[2]/batch_norm_0"; -"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFBatchNorm2d[2]/batch_norm_0" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFBatchNorm2d[2]/SymmetricQuantizer/symmetric_quantize_0"; -"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFBatchNorm2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0"; -"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0"; -"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0" -> "45 MobileNetV2/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0"; -"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0"; -"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0"; -"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0"; -"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0"; -"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0"; -"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0"; -"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0"; -"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0"; -"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0" -> "121 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0"; -"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0"; -"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0"; -"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0" -> "137 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0"; -"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0"; -"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0"; -"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0" -> "153 MobileNetV2/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0"; -"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0"; -"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0"; -"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0" -> "183 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0"; -"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0"; -"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0"; -"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[13]/SymmetricQuantizer/symmetric_quantize_0"; -"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/SymmetricQuantizer/symmetric_quantize_0" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0"; -"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0"; -"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0"; -"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0"; -"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0"; -"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0" -> "245 MobileNetV2/Sequential[features]/InvertedResidual[16]/SymmetricQuantizer/symmetric_quantize_0"; -"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/SymmetricQuantizer/symmetric_quantize_0" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; -"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; -"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d_0"; -"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d_0" -> "258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0"; -"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFBatchNorm2d[3]/batch_norm_0" -> "259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; -"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFBatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "261 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFConv2d[0]/conv2d_0"; -"260 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "261 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFConv2d[0]/conv2d_0"; -"261 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFConv2d[0]/conv2d_0" -> "262 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFBatchNorm2d[1]/batch_norm_0"; -"262 MobileNetV2/Sequential[features]/ConvBNActivation[18]/NNCFBatchNorm2d[1]/batch_norm_0" -> "263 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/hardtanh_0"; -"263 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/hardtanh_0" -> "264 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; -"264 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "265 MobileNetV2/adaptive_avg_pool2d_0"; -"265 MobileNetV2/adaptive_avg_pool2d_0" -> "266 MobileNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[MobileNetV2/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; -"266 MobileNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[MobileNetV2/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "267 MobileNetV2/reshape_0"; -"267 MobileNetV2/reshape_0" -> "268 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout_0"; -"268 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout_0" -> "270 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear_0"; -"269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "270 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear_0"; -"270 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear_0" -> "271 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"2 features.0.0.weight" -> "3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"4 MobileNetV2/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "7 MobileNetV2/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"5 features.0.1.weight" -> "7 MobileNetV2/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"6 features.0.1.bias" -> "7 MobileNetV2/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"7 MobileNetV2/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "8 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"8 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "9 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"9 MobileNetV2/Sequential[features]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"10 features.1.conv.0.0.weight" -> "11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"13 features.1.conv.0.1.weight" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"14 features.1.conv.0.1.bias" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "16 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"16 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"17 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/conv2d_0"; +"18 features.1.conv.1.weight" -> "19 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"19 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/conv2d_0"; +"20 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/Conv2d[1]/conv2d_0" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm_0"; +"21 features.1.conv.2.weight" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm_0"; +"22 features.1.conv.2.bias" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm_0"; +"23 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm_0" -> "24 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"24 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"25 features.2.conv.0.0.weight" -> "26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "30 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"28 features.2.conv.0.1.weight" -> "30 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"29 features.2.conv.0.1.bias" -> "30 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"30 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"31 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "32 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"32 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "35 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"33 features.2.conv.1.0.weight" -> "34 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"34 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "35 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"35 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"36 features.2.conv.1.1.weight" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"37 features.2.conv.1.1.bias" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"38 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "39 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"39 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "40 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"40 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"41 features.2.conv.2.weight" -> "42 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"42 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"43 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "46 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"44 features.2.conv.3.weight" -> "46 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"45 features.2.conv.3.bias" -> "46 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"46 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"47 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"47 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0"; +"48 features.3.conv.0.0.weight" -> "49 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"49 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"50 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"51 features.3.conv.0.1.weight" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"52 features.3.conv.0.1.bias" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"53 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "54 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"54 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "55 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"55 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"56 features.3.conv.1.0.weight" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"57 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"58 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"59 features.3.conv.1.1.weight" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"60 features.3.conv.1.1.bias" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"61 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "62 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"62 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "63 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"63 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"64 features.3.conv.2.weight" -> "65 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"65 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"66 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"67 features.3.conv.3.weight" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"68 features.3.conv.3.bias" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"69 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "70 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"70 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0"; +"71 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add___0" -> "72 MobileNetV2/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0"; +"72 MobileNetV2/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"73 features.4.conv.0.0.weight" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"74 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"76 features.4.conv.0.1.weight" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"77 features.4.conv.0.1.bias" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"78 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "79 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"79 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "80 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"80 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"81 features.4.conv.1.0.weight" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"82 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"83 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "86 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"84 features.4.conv.1.1.weight" -> "86 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"85 features.4.conv.1.1.bias" -> "86 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"86 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"87 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "88 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"88 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"89 features.4.conv.2.weight" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"90 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"91 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"92 features.4.conv.3.weight" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"93 features.4.conv.3.bias" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"94 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "95 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"95 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"95 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0"; +"96 features.5.conv.0.0.weight" -> "97 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"97 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"98 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"99 features.5.conv.0.1.weight" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"100 features.5.conv.0.1.bias" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"101 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "102 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"102 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"103 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "106 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"104 features.5.conv.1.0.weight" -> "105 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "106 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"106 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"107 features.5.conv.1.1.weight" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"108 features.5.conv.1.1.bias" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"109 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "110 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"110 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "111 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"111 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"112 features.5.conv.2.weight" -> "113 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"113 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"114 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"115 features.5.conv.3.weight" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"116 features.5.conv.3.bias" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"117 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "118 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"118 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0"; +"119 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add___0" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0"; +"120 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"120 MobileNetV2/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0"; +"121 features.6.conv.0.0.weight" -> "122 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"122 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"123 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"124 features.6.conv.0.1.weight" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"125 features.6.conv.0.1.bias" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"126 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "127 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"127 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"128 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"129 features.6.conv.1.0.weight" -> "130 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"130 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"131 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"132 features.6.conv.1.1.weight" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"133 features.6.conv.1.1.bias" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"134 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "135 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"135 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"136 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"137 features.6.conv.2.weight" -> "138 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"138 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"139 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"140 features.6.conv.3.weight" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"141 features.6.conv.3.bias" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"142 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "143 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"143 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0"; +"144 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add___0" -> "145 MobileNetV2/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0"; +"145 MobileNetV2/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" -> "148 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"146 features.7.conv.0.0.weight" -> "147 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"147 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "148 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"148 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"149 features.7.conv.0.1.weight" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"150 features.7.conv.0.1.bias" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"151 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"152 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "153 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"153 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"154 features.7.conv.1.0.weight" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"155 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"156 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "159 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"157 features.7.conv.1.1.weight" -> "159 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"158 features.7.conv.1.1.bias" -> "159 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"159 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"160 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "161 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"161 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "164 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"162 features.7.conv.2.weight" -> "163 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"163 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "164 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"164 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"165 features.7.conv.3.weight" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"166 features.7.conv.3.bias" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "168 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"168 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"168 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0"; +"169 features.8.conv.0.0.weight" -> "170 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"170 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"171 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"172 features.8.conv.0.1.weight" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"173 features.8.conv.0.1.bias" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"174 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "175 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"175 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "176 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"176 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"177 features.8.conv.1.0.weight" -> "178 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"178 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"179 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"180 features.8.conv.1.1.weight" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"181 features.8.conv.1.1.bias" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"182 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "183 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "184 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"184 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"185 features.8.conv.2.weight" -> "186 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"186 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"187 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"188 features.8.conv.3.weight" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"189 features.8.conv.3.bias" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"190 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "191 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"191 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0"; +"192 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add___0" -> "193 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0"; +"193 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"193 MobileNetV2/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0"; +"194 features.9.conv.0.0.weight" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"195 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"196 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"197 features.9.conv.0.1.weight" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"198 features.9.conv.0.1.bias" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"199 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "200 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"200 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"201 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"202 features.9.conv.1.0.weight" -> "203 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"203 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"204 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"205 features.9.conv.1.1.weight" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"206 features.9.conv.1.1.bias" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"207 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "208 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"208 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "209 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"209 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"210 features.9.conv.2.weight" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"211 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"212 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"213 features.9.conv.3.weight" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"214 features.9.conv.3.bias" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"215 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "216 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"216 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0"; +"217 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add___0" -> "218 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0"; +"218 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"218 MobileNetV2/Sequential[features]/InvertedResidual[9]/SymmetricQuantizer/symmetric_quantize_0" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0"; +"219 features.10.conv.0.0.weight" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"220 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"221 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "224 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"222 features.10.conv.0.1.weight" -> "224 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"223 features.10.conv.0.1.bias" -> "224 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"224 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"225 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "226 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"226 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"227 features.10.conv.1.0.weight" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"228 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"230 features.10.conv.1.1.weight" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"231 features.10.conv.1.1.bias" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"232 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "233 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"233 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "234 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"234 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"235 features.10.conv.2.weight" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"236 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"237 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "240 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"238 features.10.conv.3.weight" -> "240 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"239 features.10.conv.3.bias" -> "240 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"240 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"241 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0"; +"242 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add___0" -> "243 MobileNetV2/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0"; +"243 MobileNetV2/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" -> "246 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"244 features.11.conv.0.0.weight" -> "245 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"245 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "246 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"246 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"247 features.11.conv.0.1.weight" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"248 features.11.conv.0.1.bias" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"249 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "250 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"250 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "251 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"251 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"252 features.11.conv.1.0.weight" -> "253 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"253 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"254 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"255 features.11.conv.1.1.weight" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"256 features.11.conv.1.1.bias" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"257 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "258 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"258 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "259 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"259 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "262 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"260 features.11.conv.2.weight" -> "261 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"261 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "262 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"262 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "265 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"263 features.11.conv.3.weight" -> "265 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"264 features.11.conv.3.bias" -> "265 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"265 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "266 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"266 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "269 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"266 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "290 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0"; +"267 features.12.conv.0.0.weight" -> "268 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"268 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "269 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"269 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "272 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"270 features.12.conv.0.1.weight" -> "272 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"271 features.12.conv.0.1.bias" -> "272 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"272 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "273 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"273 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "274 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"274 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "277 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"275 features.12.conv.1.0.weight" -> "276 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"276 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "277 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"277 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "280 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"278 features.12.conv.1.1.weight" -> "280 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"279 features.12.conv.1.1.bias" -> "280 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"280 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "281 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"281 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "282 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"282 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "285 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"283 features.12.conv.2.weight" -> "284 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"284 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "285 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"285 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "288 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"286 features.12.conv.3.weight" -> "288 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"287 features.12.conv.3.bias" -> "288 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"288 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "289 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"289 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "290 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0"; +"290 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add___0" -> "291 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0"; +"291 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0" -> "294 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"291 MobileNetV2/Sequential[features]/InvertedResidual[12]/SymmetricQuantizer/symmetric_quantize_0" -> "315 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0"; +"292 features.13.conv.0.0.weight" -> "293 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"293 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "294 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"294 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "297 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"295 features.13.conv.0.1.weight" -> "297 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"296 features.13.conv.0.1.bias" -> "297 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"297 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "298 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"298 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "299 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"299 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "302 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"300 features.13.conv.1.0.weight" -> "301 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"301 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "302 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"302 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "305 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"303 features.13.conv.1.1.weight" -> "305 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"304 features.13.conv.1.1.bias" -> "305 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"305 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "306 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"306 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "307 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"307 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "310 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"308 features.13.conv.2.weight" -> "309 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"309 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "310 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"310 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "313 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"311 features.13.conv.3.weight" -> "313 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"312 features.13.conv.3.bias" -> "313 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"313 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "314 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"314 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "315 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0"; +"315 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add___0" -> "316 MobileNetV2/Sequential[features]/InvertedResidual[13]/SymmetricQuantizer/symmetric_quantize_0"; +"316 MobileNetV2/Sequential[features]/InvertedResidual[13]/SymmetricQuantizer/symmetric_quantize_0" -> "319 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"317 features.14.conv.0.0.weight" -> "318 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"318 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "319 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"319 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "322 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"320 features.14.conv.0.1.weight" -> "322 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"321 features.14.conv.0.1.bias" -> "322 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"322 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "323 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"323 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "324 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"324 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "327 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"325 features.14.conv.1.0.weight" -> "326 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"326 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "327 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"327 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "330 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"328 features.14.conv.1.1.weight" -> "330 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"329 features.14.conv.1.1.bias" -> "330 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"330 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "331 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"331 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "332 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"332 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "335 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"333 features.14.conv.2.weight" -> "334 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"334 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "335 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"335 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "338 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"336 features.14.conv.3.weight" -> "338 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"337 features.14.conv.3.bias" -> "338 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"338 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "339 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"339 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "342 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"339 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "363 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0"; +"340 features.15.conv.0.0.weight" -> "341 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"341 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "342 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"342 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "345 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"343 features.15.conv.0.1.weight" -> "345 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"344 features.15.conv.0.1.bias" -> "345 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"345 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "346 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"346 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "347 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"347 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "350 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"348 features.15.conv.1.0.weight" -> "349 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"349 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "350 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"350 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "353 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"351 features.15.conv.1.1.weight" -> "353 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"352 features.15.conv.1.1.bias" -> "353 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"353 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "354 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"354 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "355 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"355 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "358 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"356 features.15.conv.2.weight" -> "357 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"357 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "358 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"358 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "361 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"359 features.15.conv.3.weight" -> "361 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"360 features.15.conv.3.bias" -> "361 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"361 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "362 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"362 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "363 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0"; +"363 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add___0" -> "364 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0"; +"364 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0" -> "367 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"364 MobileNetV2/Sequential[features]/InvertedResidual[15]/SymmetricQuantizer/symmetric_quantize_0" -> "388 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0"; +"365 features.16.conv.0.0.weight" -> "366 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"366 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "367 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"367 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "370 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"368 features.16.conv.0.1.weight" -> "370 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"369 features.16.conv.0.1.bias" -> "370 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"370 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "371 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"371 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "372 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"372 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "375 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"373 features.16.conv.1.0.weight" -> "374 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"374 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "375 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"375 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "378 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"376 features.16.conv.1.1.weight" -> "378 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"377 features.16.conv.1.1.bias" -> "378 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"378 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "379 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"379 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "380 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"380 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "383 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"381 features.16.conv.2.weight" -> "382 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"382 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "383 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"383 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "386 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"384 features.16.conv.3.weight" -> "386 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"385 features.16.conv.3.bias" -> "386 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"386 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "387 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"387 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "388 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0"; +"388 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add___0" -> "389 MobileNetV2/Sequential[features]/InvertedResidual[16]/SymmetricQuantizer/symmetric_quantize_0"; +"389 MobileNetV2/Sequential[features]/InvertedResidual[16]/SymmetricQuantizer/symmetric_quantize_0" -> "392 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"390 features.17.conv.0.0.weight" -> "391 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"391 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "392 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"392 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "395 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"393 features.17.conv.0.1.weight" -> "395 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"394 features.17.conv.0.1.bias" -> "395 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"395 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "396 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0"; +"396 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/hardtanh_0" -> "397 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"397 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "400 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"398 features.17.conv.1.0.weight" -> "399 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"399 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "400 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"400 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "403 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"401 features.17.conv.1.1.weight" -> "403 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"402 features.17.conv.1.1.bias" -> "403 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"403 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "404 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0"; +"404 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/hardtanh_0" -> "405 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"405 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNActivation[1]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "408 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"406 features.17.conv.2.weight" -> "407 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0"; +"407 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/SymmetricQuantizer/symmetric_quantize_0" -> "408 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/conv2d_0"; +"408 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/Conv2d[2]/conv2d_0" -> "411 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"409 features.17.conv.3.weight" -> "411 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"410 features.17.conv.3.bias" -> "411 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0"; +"411 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm_0" -> "412 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"412 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "415 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/conv2d_0"; +"413 features.18.0.weight" -> "414 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"414 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "415 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/conv2d_0"; +"415 MobileNetV2/Sequential[features]/ConvBNActivation[18]/Conv2d[0]/conv2d_0" -> "418 MobileNetV2/Sequential[features]/ConvBNActivation[18]/BatchNorm2d[1]/batch_norm_0"; +"416 features.18.1.weight" -> "418 MobileNetV2/Sequential[features]/ConvBNActivation[18]/BatchNorm2d[1]/batch_norm_0"; +"417 features.18.1.bias" -> "418 MobileNetV2/Sequential[features]/ConvBNActivation[18]/BatchNorm2d[1]/batch_norm_0"; +"418 MobileNetV2/Sequential[features]/ConvBNActivation[18]/BatchNorm2d[1]/batch_norm_0" -> "419 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/hardtanh_0"; +"419 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/hardtanh_0" -> "420 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0"; +"420 MobileNetV2/Sequential[features]/ConvBNActivation[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize_0" -> "421 MobileNetV2/adaptive_avg_pool2d_0"; +"421 MobileNetV2/adaptive_avg_pool2d_0" -> "422 MobileNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[MobileNetV2/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; +"422 MobileNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[MobileNetV2/adaptive_avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "423 MobileNetV2/reshape_0"; +"423 MobileNetV2/reshape_0" -> "424 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout_0"; +"424 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout_0" -> "428 MobileNetV2/Sequential[classifier]/Linear[1]/linear_0"; +"425 classifier.1.weight" -> "427 MobileNetV2/Sequential[classifier]/Linear[1]/SymmetricQuantizer/symmetric_quantize_0"; +"426 classifier.1.bias" -> "428 MobileNetV2/Sequential[classifier]/Linear[1]/linear_0"; +"427 MobileNetV2/Sequential[classifier]/Linear[1]/SymmetricQuantizer/symmetric_quantize_0" -> "428 MobileNetV2/Sequential[classifier]/Linear[1]/linear_0"; +"428 MobileNetV2/Sequential[classifier]/Linear[1]/linear_0" -> "429 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v3_small.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v3_small.dot index 41264e4a2b3..007449d1ce8 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v3_small.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/mobilenet_v3_small.dot @@ -1,528 +1,812 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=4, type=batch_norm]; -"5 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=5, type=hardswish]; -"6 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=8, type=conv2d]; -"9 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=9, type=batch_norm]; -"10 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" [id=10, type=relu_]; -"11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/adaptive_avg_pool2d_0" [id=12, type=adaptive_avg_pool2d]; -"13 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/NNCFConv2d[fc1]/conv2d_0" [id=13, type=conv2d]; -"14 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/ReLU[relu]/relu__0" [id=14, type=relu_]; -"15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/NNCFConv2d[fc2]/conv2d_0" [id=15, type=conv2d]; -"16 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/hardsigmoid_0" [id=16, type=hardsigmoid]; -"17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_0" [id=17, type=symmetric_quantize]; -"18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0" [id=18, type=__mul__]; -"19 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_1" [id=19, type=symmetric_quantize]; -"20 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0" [id=21, type=conv2d]; -"22 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=22, type=batch_norm]; -"23 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; -"24 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=25, type=conv2d]; -"26 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=26, type=batch_norm]; -"27 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" [id=27, type=relu_]; -"28 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; -"29 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=29, type=symmetric_quantize]; -"30 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=30, type=conv2d]; -"31 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=31, type=batch_norm]; -"32 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" [id=32, type=relu_]; -"33 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; -"34 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=34, type=symmetric_quantize]; -"35 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0" [id=35, type=conv2d]; -"36 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=36, type=batch_norm]; -"37 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=37, type=symmetric_quantize]; -"38 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=38, type=symmetric_quantize]; -"39 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=39, type=conv2d]; -"40 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=40, type=batch_norm]; -"41 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" [id=41, type=relu_]; -"42 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; -"43 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=43, type=symmetric_quantize]; -"44 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=44, type=conv2d]; -"45 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=45, type=batch_norm]; -"46 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" [id=46, type=relu_]; -"47 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=47, type=symmetric_quantize]; -"48 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=48, type=symmetric_quantize]; -"49 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0" [id=49, type=conv2d]; -"50 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=50, type=batch_norm]; -"51 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=51, type=symmetric_quantize]; -"52 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0" [id=52, type=__iadd__]; -"53 MobileNetV3/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" [id=53, type=symmetric_quantize]; -"54 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=54, type=symmetric_quantize]; -"55 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=55, type=conv2d]; -"56 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=56, type=batch_norm]; -"57 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=57, type=hardswish]; -"58 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=58, type=symmetric_quantize]; -"59 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=59, type=symmetric_quantize]; -"60 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=60, type=conv2d]; -"61 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=61, type=batch_norm]; -"62 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=62, type=hardswish]; -"63 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; -"64 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=64, type=adaptive_avg_pool2d]; -"65 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=65, type=conv2d]; -"66 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=66, type=relu_]; -"67 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=67, type=conv2d]; -"68 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=68, type=hardsigmoid]; -"69 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=70, type=__mul__]; -"71 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=71, type=symmetric_quantize]; -"72 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=72, type=symmetric_quantize]; -"73 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=73, type=conv2d]; -"74 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=74, type=batch_norm]; -"75 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=76, type=symmetric_quantize]; -"77 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=77, type=conv2d]; -"78 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=78, type=batch_norm]; -"79 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=79, type=hardswish]; -"80 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; -"82 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=82, type=conv2d]; -"83 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=83, type=batch_norm]; -"84 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=84, type=hardswish]; -"85 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=86, type=adaptive_avg_pool2d]; -"87 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=87, type=conv2d]; -"88 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=88, type=relu_]; -"89 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=89, type=conv2d]; -"90 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=90, type=hardsigmoid]; -"91 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=92, type=__mul__]; -"93 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=93, type=symmetric_quantize]; -"94 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=94, type=symmetric_quantize]; -"95 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=95, type=conv2d]; -"96 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=96, type=batch_norm]; -"97 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; -"98 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0" [id=98, type=__iadd__]; -"99 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" [id=99, type=symmetric_quantize]; -"100 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=101, type=conv2d]; -"102 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=102, type=batch_norm]; -"103 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=103, type=hardswish]; -"104 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=104, type=symmetric_quantize]; -"105 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=105, type=symmetric_quantize]; -"106 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=106, type=conv2d]; -"107 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=107, type=batch_norm]; -"108 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=108, type=hardswish]; -"109 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=109, type=symmetric_quantize]; -"110 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=110, type=adaptive_avg_pool2d]; -"111 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=111, type=conv2d]; -"112 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=112, type=relu_]; -"113 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=113, type=conv2d]; -"114 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=114, type=hardsigmoid]; -"115 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=115, type=symmetric_quantize]; -"116 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=116, type=__mul__]; -"117 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=117, type=symmetric_quantize]; -"118 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=118, type=symmetric_quantize]; -"119 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=119, type=conv2d]; -"120 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=120, type=batch_norm]; -"121 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=121, type=symmetric_quantize]; -"122 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0" [id=122, type=__iadd__]; -"123 MobileNetV3/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; -"124 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=124, type=symmetric_quantize]; -"125 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=125, type=conv2d]; -"126 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=126, type=batch_norm]; -"127 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=127, type=hardswish]; -"128 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=128, type=symmetric_quantize]; -"129 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=129, type=symmetric_quantize]; -"130 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=130, type=conv2d]; -"131 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=131, type=batch_norm]; -"132 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=132, type=hardswish]; -"133 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=133, type=symmetric_quantize]; -"134 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=134, type=adaptive_avg_pool2d]; -"135 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=135, type=conv2d]; -"136 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=136, type=relu_]; -"137 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=137, type=conv2d]; -"138 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=138, type=hardsigmoid]; -"139 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; -"140 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=140, type=__mul__]; -"141 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=141, type=symmetric_quantize]; -"142 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=142, type=symmetric_quantize]; -"143 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=143, type=conv2d]; -"144 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=144, type=batch_norm]; -"145 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=145, type=symmetric_quantize]; -"146 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=146, type=symmetric_quantize]; -"147 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=147, type=conv2d]; -"148 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=148, type=batch_norm]; -"149 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=149, type=hardswish]; -"150 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=150, type=symmetric_quantize]; -"151 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=151, type=symmetric_quantize]; -"152 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=152, type=conv2d]; -"153 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=153, type=batch_norm]; -"154 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=154, type=hardswish]; -"155 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; -"156 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=156, type=adaptive_avg_pool2d]; -"157 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=157, type=conv2d]; -"158 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=158, type=relu_]; -"159 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=159, type=conv2d]; -"160 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=160, type=hardsigmoid]; -"161 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=161, type=symmetric_quantize]; -"162 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=162, type=__mul__]; -"163 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=163, type=symmetric_quantize]; -"164 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=164, type=symmetric_quantize]; -"165 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=165, type=conv2d]; -"166 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=166, type=batch_norm]; -"167 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; -"168 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0" [id=168, type=__iadd__]; -"169 MobileNetV3/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" [id=169, type=symmetric_quantize]; -"170 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=170, type=symmetric_quantize]; -"171 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=171, type=conv2d]; -"172 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=172, type=batch_norm]; -"173 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=173, type=hardswish]; -"174 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=174, type=symmetric_quantize]; -"175 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=175, type=symmetric_quantize]; -"176 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=176, type=conv2d]; -"177 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=177, type=batch_norm]; -"178 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=178, type=hardswish]; -"179 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=179, type=symmetric_quantize]; -"180 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=180, type=adaptive_avg_pool2d]; -"181 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=181, type=conv2d]; -"182 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=182, type=relu_]; -"183 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=183, type=conv2d]; -"184 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=184, type=hardsigmoid]; -"185 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=185, type=symmetric_quantize]; -"186 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=186, type=__mul__]; -"187 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=187, type=symmetric_quantize]; -"188 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=188, type=symmetric_quantize]; -"189 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=189, type=conv2d]; -"190 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=190, type=batch_norm]; -"191 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=191, type=symmetric_quantize]; -"192 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=192, type=symmetric_quantize]; -"193 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=193, type=conv2d]; -"194 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=194, type=batch_norm]; -"195 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=195, type=hardswish]; -"196 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=196, type=symmetric_quantize]; -"197 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=197, type=symmetric_quantize]; -"198 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=198, type=conv2d]; -"199 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=199, type=batch_norm]; -"200 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=200, type=hardswish]; -"201 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=201, type=symmetric_quantize]; -"202 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=202, type=adaptive_avg_pool2d]; -"203 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=203, type=conv2d]; -"204 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=204, type=relu_]; -"205 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=205, type=conv2d]; -"206 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=206, type=hardsigmoid]; -"207 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; -"208 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=208, type=__mul__]; -"209 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=209, type=symmetric_quantize]; -"210 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=210, type=symmetric_quantize]; -"211 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=211, type=conv2d]; -"212 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=212, type=batch_norm]; -"213 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=213, type=symmetric_quantize]; -"214 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0" [id=214, type=__iadd__]; -"215 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" [id=215, type=symmetric_quantize]; -"216 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=216, type=symmetric_quantize]; -"217 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" [id=217, type=conv2d]; -"218 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=218, type=batch_norm]; -"219 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=219, type=hardswish]; -"220 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=220, type=symmetric_quantize]; -"221 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=221, type=symmetric_quantize]; -"222 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" [id=222, type=conv2d]; -"223 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=223, type=batch_norm]; -"224 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=224, type=hardswish]; -"225 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=225, type=symmetric_quantize]; -"226 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=226, type=adaptive_avg_pool2d]; -"227 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" [id=227, type=conv2d]; -"228 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=228, type=relu_]; -"229 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" [id=229, type=conv2d]; -"230 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=230, type=hardsigmoid]; -"231 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=231, type=symmetric_quantize]; -"232 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=232, type=__mul__]; -"233 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=233, type=symmetric_quantize]; -"234 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=234, type=symmetric_quantize]; -"235 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" [id=235, type=conv2d]; -"236 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=236, type=batch_norm]; -"237 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=237, type=symmetric_quantize]; -"238 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0" [id=238, type=__iadd__]; -"239 MobileNetV3/Sequential[features]/InvertedResidual[11]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; -"240 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=240, type=symmetric_quantize]; -"241 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFConv2d[0]/conv2d_0" [id=241, type=conv2d]; -"242 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFBatchNorm2d[1]/batch_norm_0" [id=242, type=batch_norm]; -"243 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/hardswish_0" [id=243, type=hardswish]; -"244 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; -"245 MobileNetV3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" [id=245, type=adaptive_avg_pool2d]; -"246 MobileNetV3/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=246, type=symmetric_quantize]; -"247 MobileNetV3/flatten_0" [id=247, type=flatten]; -"248 MobileNetV3/Sequential[classifier]/NNCFLinear[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=248, type=symmetric_quantize]; -"249 MobileNetV3/Sequential[classifier]/NNCFLinear[0]/linear_0" [id=249, type=linear]; -"250 MobileNetV3/Sequential[classifier]/Hardswish[1]/hardswish_0" [id=250, type=hardswish]; -"251 MobileNetV3/Sequential[classifier]/Hardswish[1]/SymmetricQuantizer/symmetric_quantize_0" [id=251, type=symmetric_quantize]; -"252 MobileNetV3/Sequential[classifier]/Dropout[2]/dropout_0" [id=252, type=dropout]; -"253 MobileNetV3/Sequential[classifier]/NNCFLinear[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=253, type=symmetric_quantize]; -"254 MobileNetV3/Sequential[classifier]/NNCFLinear[3]/linear_0" [id=254, type=linear]; -"255 /nncf_model_output_0" [id=255, type=nncf_model_output]; +"2 features.0.0.weight" [id=2, type=nncf_model_const]; +"3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=4, type=conv2d]; +"5 features.0.1.weight" [id=5, type=nncf_model_const]; +"6 features.0.1.bias" [id=6, type=nncf_model_const]; +"7 MobileNetV3/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=7, type=batch_norm]; +"8 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=8, type=hardswish]; +"9 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=9, type=symmetric_quantize]; +"10 features.1.block.0.0.weight" [id=10, type=nncf_model_const]; +"11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=12, type=conv2d]; +"13 features.1.block.0.1.weight" [id=13, type=nncf_model_const]; +"14 features.1.block.0.1.bias" [id=14, type=nncf_model_const]; +"15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=15, type=batch_norm]; +"16 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" [id=16, type=relu_]; +"17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=17, type=symmetric_quantize]; +"18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/adaptive_avg_pool2d_0" [id=18, type=adaptive_avg_pool2d]; +"19 features.1.block.1.fc1.weight" [id=19, type=nncf_model_const]; +"20 features.1.block.1.fc1.bias" [id=20, type=nncf_model_const]; +"21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc1]/conv2d_0" [id=21, type=conv2d]; +"22 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/ReLU[relu]/relu__0" [id=22, type=relu_]; +"23 features.1.block.1.fc2.weight" [id=23, type=nncf_model_const]; +"24 features.1.block.1.fc2.bias" [id=24, type=nncf_model_const]; +"25 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc2]/conv2d_0" [id=25, type=conv2d]; +"26 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/hardsigmoid_0" [id=26, type=hardsigmoid]; +"27 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_0" [id=27, type=symmetric_quantize]; +"28 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0" [id=28, type=__mul__]; +"29 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_1" [id=29, type=symmetric_quantize]; +"30 features.1.block.2.0.weight" [id=30, type=nncf_model_const]; +"31 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; +"32 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0" [id=32, type=conv2d]; +"33 features.1.block.2.1.weight" [id=33, type=nncf_model_const]; +"34 features.1.block.2.1.bias" [id=34, type=nncf_model_const]; +"35 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0" [id=35, type=batch_norm]; +"36 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; +"37 features.2.block.0.0.weight" [id=37, type=nncf_model_const]; +"38 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=39, type=conv2d]; +"40 features.2.block.0.1.weight" [id=40, type=nncf_model_const]; +"41 features.2.block.0.1.bias" [id=41, type=nncf_model_const]; +"42 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=42, type=batch_norm]; +"43 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" [id=43, type=relu_]; +"44 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; +"45 features.2.block.1.0.weight" [id=45, type=nncf_model_const]; +"46 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=47, type=conv2d]; +"48 features.2.block.1.1.weight" [id=48, type=nncf_model_const]; +"49 features.2.block.1.1.bias" [id=49, type=nncf_model_const]; +"50 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=50, type=batch_norm]; +"51 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" [id=51, type=relu_]; +"52 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; +"53 features.2.block.2.0.weight" [id=53, type=nncf_model_const]; +"54 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; +"55 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0" [id=55, type=conv2d]; +"56 features.2.block.2.1.weight" [id=56, type=nncf_model_const]; +"57 features.2.block.2.1.bias" [id=57, type=nncf_model_const]; +"58 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0" [id=58, type=batch_norm]; +"59 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=59, type=symmetric_quantize]; +"60 features.3.block.0.0.weight" [id=60, type=nncf_model_const]; +"61 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=62, type=conv2d]; +"63 features.3.block.0.1.weight" [id=63, type=nncf_model_const]; +"64 features.3.block.0.1.bias" [id=64, type=nncf_model_const]; +"65 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=65, type=batch_norm]; +"66 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" [id=66, type=relu_]; +"67 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=67, type=symmetric_quantize]; +"68 features.3.block.1.0.weight" [id=68, type=nncf_model_const]; +"69 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; +"70 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=70, type=conv2d]; +"71 features.3.block.1.1.weight" [id=71, type=nncf_model_const]; +"72 features.3.block.1.1.bias" [id=72, type=nncf_model_const]; +"73 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=73, type=batch_norm]; +"74 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" [id=74, type=relu_]; +"75 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=75, type=symmetric_quantize]; +"76 features.3.block.2.0.weight" [id=76, type=nncf_model_const]; +"77 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=77, type=symmetric_quantize]; +"78 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0" [id=78, type=conv2d]; +"79 features.3.block.2.1.weight" [id=79, type=nncf_model_const]; +"80 features.3.block.2.1.bias" [id=80, type=nncf_model_const]; +"81 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0" [id=81, type=batch_norm]; +"82 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=82, type=symmetric_quantize]; +"83 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0" [id=83, type=__iadd__]; +"84 MobileNetV3/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 features.4.block.0.0.weight" [id=85, type=nncf_model_const]; +"86 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=87, type=conv2d]; +"88 features.4.block.0.1.weight" [id=88, type=nncf_model_const]; +"89 features.4.block.0.1.bias" [id=89, type=nncf_model_const]; +"90 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=90, type=batch_norm]; +"91 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=91, type=hardswish]; +"92 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=92, type=symmetric_quantize]; +"93 features.4.block.1.0.weight" [id=93, type=nncf_model_const]; +"94 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=95, type=conv2d]; +"96 features.4.block.1.1.weight" [id=96, type=nncf_model_const]; +"97 features.4.block.1.1.bias" [id=97, type=nncf_model_const]; +"98 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=98, type=batch_norm]; +"99 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=99, type=hardswish]; +"100 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; +"101 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=101, type=adaptive_avg_pool2d]; +"102 features.4.block.2.fc1.weight" [id=102, type=nncf_model_const]; +"103 features.4.block.2.fc1.bias" [id=103, type=nncf_model_const]; +"104 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=104, type=conv2d]; +"105 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=105, type=relu_]; +"106 features.4.block.2.fc2.weight" [id=106, type=nncf_model_const]; +"107 features.4.block.2.fc2.bias" [id=107, type=nncf_model_const]; +"108 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=108, type=conv2d]; +"109 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=109, type=hardsigmoid]; +"110 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=111, type=__mul__]; +"112 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=112, type=symmetric_quantize]; +"113 features.4.block.3.0.weight" [id=113, type=nncf_model_const]; +"114 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=115, type=conv2d]; +"116 features.4.block.3.1.weight" [id=116, type=nncf_model_const]; +"117 features.4.block.3.1.bias" [id=117, type=nncf_model_const]; +"118 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=118, type=batch_norm]; +"119 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=119, type=symmetric_quantize]; +"120 features.5.block.0.0.weight" [id=120, type=nncf_model_const]; +"121 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=121, type=symmetric_quantize]; +"122 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=122, type=conv2d]; +"123 features.5.block.0.1.weight" [id=123, type=nncf_model_const]; +"124 features.5.block.0.1.bias" [id=124, type=nncf_model_const]; +"125 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=125, type=batch_norm]; +"126 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=126, type=hardswish]; +"127 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=127, type=symmetric_quantize]; +"128 features.5.block.1.0.weight" [id=128, type=nncf_model_const]; +"129 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=130, type=conv2d]; +"131 features.5.block.1.1.weight" [id=131, type=nncf_model_const]; +"132 features.5.block.1.1.bias" [id=132, type=nncf_model_const]; +"133 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=133, type=batch_norm]; +"134 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=134, type=hardswish]; +"135 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=135, type=symmetric_quantize]; +"136 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=136, type=adaptive_avg_pool2d]; +"137 features.5.block.2.fc1.weight" [id=137, type=nncf_model_const]; +"138 features.5.block.2.fc1.bias" [id=138, type=nncf_model_const]; +"139 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=139, type=conv2d]; +"140 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=140, type=relu_]; +"141 features.5.block.2.fc2.weight" [id=141, type=nncf_model_const]; +"142 features.5.block.2.fc2.bias" [id=142, type=nncf_model_const]; +"143 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=143, type=conv2d]; +"144 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=144, type=hardsigmoid]; +"145 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=146, type=__mul__]; +"147 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=147, type=symmetric_quantize]; +"148 features.5.block.3.0.weight" [id=148, type=nncf_model_const]; +"149 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=150, type=conv2d]; +"151 features.5.block.3.1.weight" [id=151, type=nncf_model_const]; +"152 features.5.block.3.1.bias" [id=152, type=nncf_model_const]; +"153 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=153, type=batch_norm]; +"154 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=154, type=symmetric_quantize]; +"155 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0" [id=155, type=__iadd__]; +"156 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 features.6.block.0.0.weight" [id=157, type=nncf_model_const]; +"158 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=158, type=symmetric_quantize]; +"159 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=159, type=conv2d]; +"160 features.6.block.0.1.weight" [id=160, type=nncf_model_const]; +"161 features.6.block.0.1.bias" [id=161, type=nncf_model_const]; +"162 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=162, type=batch_norm]; +"163 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=163, type=hardswish]; +"164 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=164, type=symmetric_quantize]; +"165 features.6.block.1.0.weight" [id=165, type=nncf_model_const]; +"166 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=166, type=symmetric_quantize]; +"167 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=167, type=conv2d]; +"168 features.6.block.1.1.weight" [id=168, type=nncf_model_const]; +"169 features.6.block.1.1.bias" [id=169, type=nncf_model_const]; +"170 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=170, type=batch_norm]; +"171 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=171, type=hardswish]; +"172 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=172, type=symmetric_quantize]; +"173 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=173, type=adaptive_avg_pool2d]; +"174 features.6.block.2.fc1.weight" [id=174, type=nncf_model_const]; +"175 features.6.block.2.fc1.bias" [id=175, type=nncf_model_const]; +"176 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=176, type=conv2d]; +"177 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=177, type=relu_]; +"178 features.6.block.2.fc2.weight" [id=178, type=nncf_model_const]; +"179 features.6.block.2.fc2.bias" [id=179, type=nncf_model_const]; +"180 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=180, type=conv2d]; +"181 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=181, type=hardsigmoid]; +"182 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=183, type=__mul__]; +"184 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=184, type=symmetric_quantize]; +"185 features.6.block.3.0.weight" [id=185, type=nncf_model_const]; +"186 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=187, type=conv2d]; +"188 features.6.block.3.1.weight" [id=188, type=nncf_model_const]; +"189 features.6.block.3.1.bias" [id=189, type=nncf_model_const]; +"190 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=190, type=batch_norm]; +"191 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=191, type=symmetric_quantize]; +"192 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0" [id=192, type=__iadd__]; +"193 MobileNetV3/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" [id=193, type=symmetric_quantize]; +"194 features.7.block.0.0.weight" [id=194, type=nncf_model_const]; +"195 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=196, type=conv2d]; +"197 features.7.block.0.1.weight" [id=197, type=nncf_model_const]; +"198 features.7.block.0.1.bias" [id=198, type=nncf_model_const]; +"199 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=199, type=batch_norm]; +"200 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=200, type=hardswish]; +"201 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=201, type=symmetric_quantize]; +"202 features.7.block.1.0.weight" [id=202, type=nncf_model_const]; +"203 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; +"204 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=204, type=conv2d]; +"205 features.7.block.1.1.weight" [id=205, type=nncf_model_const]; +"206 features.7.block.1.1.bias" [id=206, type=nncf_model_const]; +"207 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=207, type=batch_norm]; +"208 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=208, type=hardswish]; +"209 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; +"210 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=210, type=adaptive_avg_pool2d]; +"211 features.7.block.2.fc1.weight" [id=211, type=nncf_model_const]; +"212 features.7.block.2.fc1.bias" [id=212, type=nncf_model_const]; +"213 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=213, type=conv2d]; +"214 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=214, type=relu_]; +"215 features.7.block.2.fc2.weight" [id=215, type=nncf_model_const]; +"216 features.7.block.2.fc2.bias" [id=216, type=nncf_model_const]; +"217 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=217, type=conv2d]; +"218 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=218, type=hardsigmoid]; +"219 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=219, type=symmetric_quantize]; +"220 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=220, type=__mul__]; +"221 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=221, type=symmetric_quantize]; +"222 features.7.block.3.0.weight" [id=222, type=nncf_model_const]; +"223 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; +"224 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=224, type=conv2d]; +"225 features.7.block.3.1.weight" [id=225, type=nncf_model_const]; +"226 features.7.block.3.1.bias" [id=226, type=nncf_model_const]; +"227 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=227, type=batch_norm]; +"228 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 features.8.block.0.0.weight" [id=229, type=nncf_model_const]; +"230 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=230, type=symmetric_quantize]; +"231 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=231, type=conv2d]; +"232 features.8.block.0.1.weight" [id=232, type=nncf_model_const]; +"233 features.8.block.0.1.bias" [id=233, type=nncf_model_const]; +"234 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=234, type=batch_norm]; +"235 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=235, type=hardswish]; +"236 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=236, type=symmetric_quantize]; +"237 features.8.block.1.0.weight" [id=237, type=nncf_model_const]; +"238 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=238, type=symmetric_quantize]; +"239 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=239, type=conv2d]; +"240 features.8.block.1.1.weight" [id=240, type=nncf_model_const]; +"241 features.8.block.1.1.bias" [id=241, type=nncf_model_const]; +"242 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=242, type=batch_norm]; +"243 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=243, type=hardswish]; +"244 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; +"245 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=245, type=adaptive_avg_pool2d]; +"246 features.8.block.2.fc1.weight" [id=246, type=nncf_model_const]; +"247 features.8.block.2.fc1.bias" [id=247, type=nncf_model_const]; +"248 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=248, type=conv2d]; +"249 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=249, type=relu_]; +"250 features.8.block.2.fc2.weight" [id=250, type=nncf_model_const]; +"251 features.8.block.2.fc2.bias" [id=251, type=nncf_model_const]; +"252 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=252, type=conv2d]; +"253 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=253, type=hardsigmoid]; +"254 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=254, type=symmetric_quantize]; +"255 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=255, type=__mul__]; +"256 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=256, type=symmetric_quantize]; +"257 features.8.block.3.0.weight" [id=257, type=nncf_model_const]; +"258 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=258, type=symmetric_quantize]; +"259 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=259, type=conv2d]; +"260 features.8.block.3.1.weight" [id=260, type=nncf_model_const]; +"261 features.8.block.3.1.bias" [id=261, type=nncf_model_const]; +"262 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=262, type=batch_norm]; +"263 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=263, type=symmetric_quantize]; +"264 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0" [id=264, type=__iadd__]; +"265 MobileNetV3/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" [id=265, type=symmetric_quantize]; +"266 features.9.block.0.0.weight" [id=266, type=nncf_model_const]; +"267 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=267, type=symmetric_quantize]; +"268 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=268, type=conv2d]; +"269 features.9.block.0.1.weight" [id=269, type=nncf_model_const]; +"270 features.9.block.0.1.bias" [id=270, type=nncf_model_const]; +"271 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=271, type=batch_norm]; +"272 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=272, type=hardswish]; +"273 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=273, type=symmetric_quantize]; +"274 features.9.block.1.0.weight" [id=274, type=nncf_model_const]; +"275 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; +"276 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=276, type=conv2d]; +"277 features.9.block.1.1.weight" [id=277, type=nncf_model_const]; +"278 features.9.block.1.1.bias" [id=278, type=nncf_model_const]; +"279 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=279, type=batch_norm]; +"280 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=280, type=hardswish]; +"281 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=281, type=symmetric_quantize]; +"282 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=282, type=adaptive_avg_pool2d]; +"283 features.9.block.2.fc1.weight" [id=283, type=nncf_model_const]; +"284 features.9.block.2.fc1.bias" [id=284, type=nncf_model_const]; +"285 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=285, type=conv2d]; +"286 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=286, type=relu_]; +"287 features.9.block.2.fc2.weight" [id=287, type=nncf_model_const]; +"288 features.9.block.2.fc2.bias" [id=288, type=nncf_model_const]; +"289 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=289, type=conv2d]; +"290 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=290, type=hardsigmoid]; +"291 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=292, type=__mul__]; +"293 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=293, type=symmetric_quantize]; +"294 features.9.block.3.0.weight" [id=294, type=nncf_model_const]; +"295 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=295, type=symmetric_quantize]; +"296 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=296, type=conv2d]; +"297 features.9.block.3.1.weight" [id=297, type=nncf_model_const]; +"298 features.9.block.3.1.bias" [id=298, type=nncf_model_const]; +"299 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=299, type=batch_norm]; +"300 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=300, type=symmetric_quantize]; +"301 features.10.block.0.0.weight" [id=301, type=nncf_model_const]; +"302 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=302, type=symmetric_quantize]; +"303 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=303, type=conv2d]; +"304 features.10.block.0.1.weight" [id=304, type=nncf_model_const]; +"305 features.10.block.0.1.bias" [id=305, type=nncf_model_const]; +"306 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=306, type=batch_norm]; +"307 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=307, type=hardswish]; +"308 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=308, type=symmetric_quantize]; +"309 features.10.block.1.0.weight" [id=309, type=nncf_model_const]; +"310 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=310, type=symmetric_quantize]; +"311 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=311, type=conv2d]; +"312 features.10.block.1.1.weight" [id=312, type=nncf_model_const]; +"313 features.10.block.1.1.bias" [id=313, type=nncf_model_const]; +"314 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=314, type=batch_norm]; +"315 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=315, type=hardswish]; +"316 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=316, type=symmetric_quantize]; +"317 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=317, type=adaptive_avg_pool2d]; +"318 features.10.block.2.fc1.weight" [id=318, type=nncf_model_const]; +"319 features.10.block.2.fc1.bias" [id=319, type=nncf_model_const]; +"320 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=320, type=conv2d]; +"321 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=321, type=relu_]; +"322 features.10.block.2.fc2.weight" [id=322, type=nncf_model_const]; +"323 features.10.block.2.fc2.bias" [id=323, type=nncf_model_const]; +"324 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=324, type=conv2d]; +"325 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=325, type=hardsigmoid]; +"326 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=326, type=symmetric_quantize]; +"327 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=327, type=__mul__]; +"328 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=328, type=symmetric_quantize]; +"329 features.10.block.3.0.weight" [id=329, type=nncf_model_const]; +"330 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=330, type=symmetric_quantize]; +"331 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=331, type=conv2d]; +"332 features.10.block.3.1.weight" [id=332, type=nncf_model_const]; +"333 features.10.block.3.1.bias" [id=333, type=nncf_model_const]; +"334 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=334, type=batch_norm]; +"335 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0" [id=336, type=__iadd__]; +"337 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 features.11.block.0.0.weight" [id=338, type=nncf_model_const]; +"339 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" [id=340, type=conv2d]; +"341 features.11.block.0.1.weight" [id=341, type=nncf_model_const]; +"342 features.11.block.0.1.bias" [id=342, type=nncf_model_const]; +"343 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" [id=343, type=batch_norm]; +"344 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" [id=344, type=hardswish]; +"345 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=345, type=symmetric_quantize]; +"346 features.11.block.1.0.weight" [id=346, type=nncf_model_const]; +"347 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; +"348 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" [id=348, type=conv2d]; +"349 features.11.block.1.1.weight" [id=349, type=nncf_model_const]; +"350 features.11.block.1.1.bias" [id=350, type=nncf_model_const]; +"351 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" [id=351, type=batch_norm]; +"352 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" [id=352, type=hardswish]; +"353 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=353, type=symmetric_quantize]; +"354 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" [id=354, type=adaptive_avg_pool2d]; +"355 features.11.block.2.fc1.weight" [id=355, type=nncf_model_const]; +"356 features.11.block.2.fc1.bias" [id=356, type=nncf_model_const]; +"357 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" [id=357, type=conv2d]; +"358 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" [id=358, type=relu_]; +"359 features.11.block.2.fc2.weight" [id=359, type=nncf_model_const]; +"360 features.11.block.2.fc2.bias" [id=360, type=nncf_model_const]; +"361 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" [id=361, type=conv2d]; +"362 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" [id=362, type=hardsigmoid]; +"363 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" [id=363, type=symmetric_quantize]; +"364 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0" [id=364, type=__mul__]; +"365 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" [id=365, type=symmetric_quantize]; +"366 features.11.block.3.0.weight" [id=366, type=nncf_model_const]; +"367 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=367, type=symmetric_quantize]; +"368 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" [id=368, type=conv2d]; +"369 features.11.block.3.1.weight" [id=369, type=nncf_model_const]; +"370 features.11.block.3.1.bias" [id=370, type=nncf_model_const]; +"371 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" [id=371, type=batch_norm]; +"372 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=372, type=symmetric_quantize]; +"373 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0" [id=373, type=__iadd__]; +"374 MobileNetV3/Sequential[features]/InvertedResidual[11]/SymmetricQuantizer/symmetric_quantize_0" [id=374, type=symmetric_quantize]; +"375 features.12.0.weight" [id=375, type=nncf_model_const]; +"376 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=376, type=symmetric_quantize]; +"377 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/conv2d_0" [id=377, type=conv2d]; +"378 features.12.1.weight" [id=378, type=nncf_model_const]; +"379 features.12.1.bias" [id=379, type=nncf_model_const]; +"380 MobileNetV3/Sequential[features]/ConvBNActivation[12]/BatchNorm2d[1]/batch_norm_0" [id=380, type=batch_norm]; +"381 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/hardswish_0" [id=381, type=hardswish]; +"382 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" [id=382, type=symmetric_quantize]; +"383 MobileNetV3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" [id=383, type=adaptive_avg_pool2d]; +"384 MobileNetV3/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=384, type=symmetric_quantize]; +"385 MobileNetV3/flatten_0" [id=385, type=flatten]; +"386 classifier.0.weight" [id=386, type=nncf_model_const]; +"387 classifier.0.bias" [id=387, type=nncf_model_const]; +"388 MobileNetV3/Sequential[classifier]/Linear[0]/SymmetricQuantizer/symmetric_quantize_0" [id=388, type=symmetric_quantize]; +"389 MobileNetV3/Sequential[classifier]/Linear[0]/linear_0" [id=389, type=linear]; +"390 MobileNetV3/Sequential[classifier]/Hardswish[1]/hardswish_0" [id=390, type=hardswish]; +"391 MobileNetV3/Sequential[classifier]/Hardswish[1]/SymmetricQuantizer/symmetric_quantize_0" [id=391, type=symmetric_quantize]; +"392 MobileNetV3/Sequential[classifier]/Dropout[2]/dropout_0" [id=392, type=dropout]; +"393 classifier.3.weight" [id=393, type=nncf_model_const]; +"394 classifier.3.bias" [id=394, type=nncf_model_const]; +"395 MobileNetV3/Sequential[classifier]/Linear[3]/SymmetricQuantizer/symmetric_quantize_0" [id=395, type=symmetric_quantize]; +"396 MobileNetV3/Sequential[classifier]/Linear[3]/linear_0" [id=396, type=linear]; +"397 /nncf_model_output_0" [id=397, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"2 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "5 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"5 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "6 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"6 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "8 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"7 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"8 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "9 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"9 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "10 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0"; -"10 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" -> "11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/adaptive_avg_pool2d_0"; -"11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0"; -"12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/adaptive_avg_pool2d_0" -> "13 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/NNCFConv2d[fc1]/conv2d_0"; -"13 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/NNCFConv2d[fc1]/conv2d_0" -> "14 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/ReLU[relu]/relu__0"; -"14 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/ReLU[relu]/relu__0" -> "15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/NNCFConv2d[fc2]/conv2d_0"; -"15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/NNCFConv2d[fc2]/conv2d_0" -> "16 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/hardsigmoid_0"; -"16 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/hardsigmoid_0" -> "17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_0"; -"17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_0" -> "18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0"; -"18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0" -> "19 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_1"; -"19 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_1" -> "21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0"; -"20 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0"; -"21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0" -> "22 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"22 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "23 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"23 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "25 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"24 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "25 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"25 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "26 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"26 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "27 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0"; -"27 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" -> "28 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"28 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "30 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"29 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "30 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"30 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "31 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"31 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "32 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0"; -"32 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" -> "33 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"33 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "35 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0"; -"34 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "35 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0"; -"35 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0" -> "36 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"36 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "37 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"37 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "39 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"37 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "52 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0"; -"38 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "39 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"39 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "40 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"40 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "41 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0"; -"41 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" -> "42 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"42 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "44 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"43 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "44 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"44 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "45 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"45 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "46 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0"; -"46 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" -> "47 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"47 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "49 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0"; -"48 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "49 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0"; -"49 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFConv2d[0]/conv2d_0" -> "50 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"50 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "51 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"51 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "52 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0"; -"52 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0" -> "53 MobileNetV3/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0"; -"53 MobileNetV3/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" -> "55 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"54 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "55 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"55 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "56 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"56 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "57 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"57 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "58 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"58 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "60 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"59 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "60 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"60 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "61 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"61 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "62 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"62 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "63 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"63 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "64 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"63 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "70 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"64 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "65 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"65 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "66 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"66 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "67 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"67 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "68 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"68 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "69 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"69 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "70 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"70 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "71 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"71 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "73 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"72 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "73 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"73 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "74 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"74 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "75 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"75 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "77 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"75 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "98 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0"; -"76 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "77 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"77 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "78 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"78 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "79 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"79 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "80 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"80 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "82 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"81 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"82 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "83 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"83 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "84 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"84 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "85 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"85 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "86 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"85 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "92 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"86 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "87 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"87 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "88 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"88 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "89 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"89 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "90 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"90 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "91 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"91 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "92 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"92 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "93 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"93 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "95 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"94 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "95 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"95 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "96 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"96 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "97 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"97 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "98 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0"; -"98 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0" -> "99 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0"; -"99 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "101 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"99 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "122 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0"; -"100 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "101 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"101 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "102 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"102 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "103 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"103 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "104 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"104 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "106 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"105 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "106 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"106 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "107 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"107 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "108 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"108 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "109 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"109 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "110 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"109 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "116 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"110 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "111 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"111 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "112 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"112 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "113 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"113 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "114 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"114 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "115 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"115 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "116 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"116 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "117 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"117 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "119 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"118 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "119 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"119 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "120 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"120 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "121 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"121 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "122 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0"; -"122 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0" -> "123 MobileNetV3/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0"; -"123 MobileNetV3/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" -> "125 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"124 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "125 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"125 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "126 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"126 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "127 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"127 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "128 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"128 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "130 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"129 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "130 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"130 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "131 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"131 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "132 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"132 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "133 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"133 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "134 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"133 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "140 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"134 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "135 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"135 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "136 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"136 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "137 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"137 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "138 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"138 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "139 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"139 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "140 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"140 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "141 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"141 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "143 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"142 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "143 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"143 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "144 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"144 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "145 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"145 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "147 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"145 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "168 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0"; -"146 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "147 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"147 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "148 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"148 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "149 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"149 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "150 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"150 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "152 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"151 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "152 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"152 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "153 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"153 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "154 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"154 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "155 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"155 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "156 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"155 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "162 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"156 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "157 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"157 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "158 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"158 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "159 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"159 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "160 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"160 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "161 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"161 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "162 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"162 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "163 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"163 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "165 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"164 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "165 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"165 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "166 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"166 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "167 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"167 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "168 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0"; -"168 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0" -> "169 MobileNetV3/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0"; -"169 MobileNetV3/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" -> "171 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"170 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "171 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"171 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "172 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"172 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "173 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"173 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "174 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"174 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "176 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"175 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "176 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"176 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "177 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"177 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "178 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"178 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "179 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"179 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "180 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"179 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "186 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"180 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "181 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"181 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "182 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"182 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "183 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"183 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "184 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"184 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "185 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"185 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "186 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"186 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "187 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"187 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "189 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"188 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "189 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"189 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "190 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"190 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "191 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"191 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "193 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"191 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "214 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0"; -"192 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "193 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"193 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "194 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"194 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "195 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"195 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "196 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"196 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "198 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"197 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "198 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"198 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "199 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"199 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "200 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"200 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "201 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"201 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "202 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"201 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "208 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"202 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "203 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"203 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "204 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"204 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "205 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"205 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "206 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"206 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "207 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"207 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "208 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"208 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "209 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"209 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "211 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"210 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "211 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"211 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "212 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"212 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "213 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"213 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "214 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0"; -"214 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0" -> "215 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0"; -"215 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" -> "217 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"215 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" -> "238 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0"; -"216 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "217 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0"; -"217 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFConv2d[0]/conv2d_0" -> "218 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"218 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "219 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; -"219 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "220 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"220 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "222 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"221 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "222 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0"; -"222 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFConv2d[0]/conv2d_0" -> "223 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"223 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "224 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; -"224 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "225 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"225 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "226 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; -"225 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "232 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"226 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "227 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0"; -"227 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc1]/conv2d_0" -> "228 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; -"228 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "229 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0"; -"229 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/NNCFConv2d[fc2]/conv2d_0" -> "230 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; -"230 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "231 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; -"231 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "232 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; -"232 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "233 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; -"233 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "235 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"234 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "235 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0"; -"235 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFConv2d[0]/conv2d_0" -> "236 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"236 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "237 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"237 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "238 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0"; -"238 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0" -> "239 MobileNetV3/Sequential[features]/InvertedResidual[11]/SymmetricQuantizer/symmetric_quantize_0"; -"239 MobileNetV3/Sequential[features]/InvertedResidual[11]/SymmetricQuantizer/symmetric_quantize_0" -> "241 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFConv2d[0]/conv2d_0"; -"240 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "241 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFConv2d[0]/conv2d_0"; -"241 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFConv2d[0]/conv2d_0" -> "242 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFBatchNorm2d[1]/batch_norm_0"; -"242 MobileNetV3/Sequential[features]/ConvBNActivation[12]/NNCFBatchNorm2d[1]/batch_norm_0" -> "243 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/hardswish_0"; -"243 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/hardswish_0" -> "244 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; -"244 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "245 MobileNetV3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0"; -"245 MobileNetV3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" -> "246 MobileNetV3/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; -"246 MobileNetV3/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "247 MobileNetV3/flatten_0"; -"247 MobileNetV3/flatten_0" -> "249 MobileNetV3/Sequential[classifier]/NNCFLinear[0]/linear_0"; -"248 MobileNetV3/Sequential[classifier]/NNCFLinear[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "249 MobileNetV3/Sequential[classifier]/NNCFLinear[0]/linear_0"; -"249 MobileNetV3/Sequential[classifier]/NNCFLinear[0]/linear_0" -> "250 MobileNetV3/Sequential[classifier]/Hardswish[1]/hardswish_0"; -"250 MobileNetV3/Sequential[classifier]/Hardswish[1]/hardswish_0" -> "251 MobileNetV3/Sequential[classifier]/Hardswish[1]/SymmetricQuantizer/symmetric_quantize_0"; -"251 MobileNetV3/Sequential[classifier]/Hardswish[1]/SymmetricQuantizer/symmetric_quantize_0" -> "252 MobileNetV3/Sequential[classifier]/Dropout[2]/dropout_0"; -"252 MobileNetV3/Sequential[classifier]/Dropout[2]/dropout_0" -> "254 MobileNetV3/Sequential[classifier]/NNCFLinear[3]/linear_0"; -"253 MobileNetV3/Sequential[classifier]/NNCFLinear[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "254 MobileNetV3/Sequential[classifier]/NNCFLinear[3]/linear_0"; -"254 MobileNetV3/Sequential[classifier]/NNCFLinear[3]/linear_0" -> "255 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"2 features.0.0.weight" -> "3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"4 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "7 MobileNetV3/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"5 features.0.1.weight" -> "7 MobileNetV3/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"6 features.0.1.bias" -> "7 MobileNetV3/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"7 MobileNetV3/Sequential[features]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "8 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"8 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "9 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"9 MobileNetV3/Sequential[features]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"10 features.1.block.0.0.weight" -> "11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"11 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"12 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"13 features.1.block.0.1.weight" -> "15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"14 features.1.block.0.1.bias" -> "15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"15 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "16 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0"; +"16 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" -> "17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/adaptive_avg_pool2d_0"; +"17 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "28 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0"; +"18 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/adaptive_avg_pool2d_0" -> "21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc1]/conv2d_0"; +"19 features.1.block.1.fc1.weight" -> "21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc1]/conv2d_0"; +"20 features.1.block.1.fc1.bias" -> "21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc1]/conv2d_0"; +"21 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc1]/conv2d_0" -> "22 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/ReLU[relu]/relu__0"; +"22 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/ReLU[relu]/relu__0" -> "25 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc2]/conv2d_0"; +"23 features.1.block.1.fc2.weight" -> "25 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc2]/conv2d_0"; +"24 features.1.block.1.fc2.bias" -> "25 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc2]/conv2d_0"; +"25 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/Conv2d[fc2]/conv2d_0" -> "26 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/hardsigmoid_0"; +"26 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/hardsigmoid_0" -> "27 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_0"; +"27 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_0" -> "28 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0"; +"28 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/__mul___0" -> "29 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_1"; +"29 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/SqueezeExcitation[1]/SymmetricQuantizer/symmetric_quantize_1" -> "32 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0"; +"30 features.1.block.2.0.weight" -> "31 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"31 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "32 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0"; +"32 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0" -> "35 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"33 features.1.block.2.1.weight" -> "35 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"34 features.1.block.2.1.bias" -> "35 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"35 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0" -> "36 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"36 MobileNetV3/Sequential[features]/InvertedResidual[1]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "39 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"37 features.2.block.0.0.weight" -> "38 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"38 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "39 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"39 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "42 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"40 features.2.block.0.1.weight" -> "42 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"41 features.2.block.0.1.bias" -> "42 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"42 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "43 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0"; +"43 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" -> "44 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"44 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "47 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"45 features.2.block.1.0.weight" -> "46 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"46 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "47 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"47 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "50 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"48 features.2.block.1.1.weight" -> "50 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"49 features.2.block.1.1.bias" -> "50 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"50 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "51 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0"; +"51 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" -> "52 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"52 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "55 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0"; +"53 features.2.block.2.0.weight" -> "54 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"54 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "55 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0"; +"55 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0" -> "58 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"56 features.2.block.2.1.weight" -> "58 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"57 features.2.block.2.1.bias" -> "58 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"58 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0" -> "59 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"59 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "62 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"59 MobileNetV3/Sequential[features]/InvertedResidual[2]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "83 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0"; +"60 features.3.block.0.0.weight" -> "61 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"61 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "62 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"62 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "65 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"63 features.3.block.0.1.weight" -> "65 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"64 features.3.block.0.1.bias" -> "65 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"65 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "66 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0"; +"66 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/relu__0" -> "67 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"67 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "70 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"68 features.3.block.1.0.weight" -> "69 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"69 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "70 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"70 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "73 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"71 features.3.block.1.1.weight" -> "73 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"72 features.3.block.1.1.bias" -> "73 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"73 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "74 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0"; +"74 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/relu__0" -> "75 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"75 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "78 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0"; +"76 features.3.block.2.0.weight" -> "77 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"77 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "78 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0"; +"78 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/Conv2d[0]/conv2d_0" -> "81 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"79 features.3.block.2.1.weight" -> "81 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"80 features.3.block.2.1.bias" -> "81 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0"; +"81 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/batch_norm_0" -> "82 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"82 MobileNetV3/Sequential[features]/InvertedResidual[3]/Sequential[block]/ConvBNActivation[2]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "83 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0"; +"83 MobileNetV3/Sequential[features]/InvertedResidual[3]/__iadd___0" -> "84 MobileNetV3/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0"; +"84 MobileNetV3/Sequential[features]/InvertedResidual[3]/SymmetricQuantizer/symmetric_quantize_0" -> "87 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"85 features.4.block.0.0.weight" -> "86 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"86 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "87 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"87 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "90 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"88 features.4.block.0.1.weight" -> "90 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"89 features.4.block.0.1.bias" -> "90 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"90 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "91 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"91 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "92 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"92 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "95 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"93 features.4.block.1.0.weight" -> "94 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"94 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "95 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"95 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "98 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"96 features.4.block.1.1.weight" -> "98 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"97 features.4.block.1.1.bias" -> "98 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"98 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "99 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"99 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "100 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"100 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "101 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"100 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "111 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"101 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "104 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"102 features.4.block.2.fc1.weight" -> "104 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"103 features.4.block.2.fc1.bias" -> "104 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"104 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "105 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"105 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "108 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"106 features.4.block.2.fc2.weight" -> "108 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"107 features.4.block.2.fc2.bias" -> "108 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"108 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "109 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"109 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "110 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"110 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "111 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"111 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "112 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"112 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "115 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"113 features.4.block.3.0.weight" -> "114 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"114 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "115 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"115 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "118 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"116 features.4.block.3.1.weight" -> "118 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"117 features.4.block.3.1.bias" -> "118 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"118 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "119 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"119 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "122 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"119 MobileNetV3/Sequential[features]/InvertedResidual[4]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "155 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0"; +"120 features.5.block.0.0.weight" -> "121 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"121 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "122 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"122 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "125 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"123 features.5.block.0.1.weight" -> "125 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"124 features.5.block.0.1.bias" -> "125 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"125 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "126 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"126 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "127 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"127 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "130 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"128 features.5.block.1.0.weight" -> "129 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"129 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "130 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"130 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "133 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"131 features.5.block.1.1.weight" -> "133 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"132 features.5.block.1.1.bias" -> "133 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"133 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "134 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"134 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "135 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"135 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "136 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"135 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "146 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"136 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "139 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"137 features.5.block.2.fc1.weight" -> "139 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"138 features.5.block.2.fc1.bias" -> "139 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"139 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "140 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"140 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "143 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"141 features.5.block.2.fc2.weight" -> "143 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"142 features.5.block.2.fc2.bias" -> "143 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"143 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "144 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"144 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "145 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"145 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "146 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"146 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "147 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"147 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "150 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"148 features.5.block.3.0.weight" -> "149 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"149 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "150 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"150 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "153 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"151 features.5.block.3.1.weight" -> "153 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"152 features.5.block.3.1.bias" -> "153 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"153 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "154 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"154 MobileNetV3/Sequential[features]/InvertedResidual[5]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "155 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0"; +"155 MobileNetV3/Sequential[features]/InvertedResidual[5]/__iadd___0" -> "156 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0"; +"156 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "159 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"156 MobileNetV3/Sequential[features]/InvertedResidual[5]/SymmetricQuantizer/symmetric_quantize_0" -> "192 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0"; +"157 features.6.block.0.0.weight" -> "158 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"158 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "159 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"159 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "162 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"160 features.6.block.0.1.weight" -> "162 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"161 features.6.block.0.1.bias" -> "162 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"162 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "163 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"163 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "164 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"164 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "167 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"165 features.6.block.1.0.weight" -> "166 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"166 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "167 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"167 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "170 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"168 features.6.block.1.1.weight" -> "170 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"169 features.6.block.1.1.bias" -> "170 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"170 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "171 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"171 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "172 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"172 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "173 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"172 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "183 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"173 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "176 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"174 features.6.block.2.fc1.weight" -> "176 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"175 features.6.block.2.fc1.bias" -> "176 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"176 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "177 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"177 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "180 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"178 features.6.block.2.fc2.weight" -> "180 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"179 features.6.block.2.fc2.bias" -> "180 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"180 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "181 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"181 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "182 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"182 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "183 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"183 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "184 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"184 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "187 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"185 features.6.block.3.0.weight" -> "186 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"186 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "187 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"187 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "190 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"188 features.6.block.3.1.weight" -> "190 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"189 features.6.block.3.1.bias" -> "190 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"190 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "191 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"191 MobileNetV3/Sequential[features]/InvertedResidual[6]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "192 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0"; +"192 MobileNetV3/Sequential[features]/InvertedResidual[6]/__iadd___0" -> "193 MobileNetV3/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0"; +"193 MobileNetV3/Sequential[features]/InvertedResidual[6]/SymmetricQuantizer/symmetric_quantize_0" -> "196 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"194 features.7.block.0.0.weight" -> "195 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"195 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "196 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"196 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "199 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"197 features.7.block.0.1.weight" -> "199 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"198 features.7.block.0.1.bias" -> "199 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"199 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "200 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"200 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "201 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"201 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "204 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"202 features.7.block.1.0.weight" -> "203 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"203 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "204 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"204 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "207 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"205 features.7.block.1.1.weight" -> "207 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"206 features.7.block.1.1.bias" -> "207 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"207 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "208 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"208 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "209 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"209 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "210 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"209 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "220 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"210 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "213 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"211 features.7.block.2.fc1.weight" -> "213 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"212 features.7.block.2.fc1.bias" -> "213 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"213 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "214 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"214 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "217 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"215 features.7.block.2.fc2.weight" -> "217 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"216 features.7.block.2.fc2.bias" -> "217 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"217 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "218 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"218 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "219 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"219 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "220 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"220 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "221 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"221 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "224 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"222 features.7.block.3.0.weight" -> "223 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"223 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "224 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"224 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "227 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"225 features.7.block.3.1.weight" -> "227 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"226 features.7.block.3.1.bias" -> "227 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"227 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "228 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"228 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "231 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"228 MobileNetV3/Sequential[features]/InvertedResidual[7]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "264 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0"; +"229 features.8.block.0.0.weight" -> "230 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"230 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "231 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"231 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "234 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"232 features.8.block.0.1.weight" -> "234 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"233 features.8.block.0.1.bias" -> "234 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"234 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "235 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"235 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "236 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"236 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "239 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"237 features.8.block.1.0.weight" -> "238 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"238 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "239 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"239 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "242 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"240 features.8.block.1.1.weight" -> "242 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"241 features.8.block.1.1.bias" -> "242 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"242 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "243 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"243 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "244 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"244 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "245 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"244 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "255 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"245 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "248 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"246 features.8.block.2.fc1.weight" -> "248 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"247 features.8.block.2.fc1.bias" -> "248 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"248 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "249 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"249 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "252 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"250 features.8.block.2.fc2.weight" -> "252 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"251 features.8.block.2.fc2.bias" -> "252 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"252 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "253 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"253 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "254 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"254 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "255 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"255 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "256 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"256 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "259 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"257 features.8.block.3.0.weight" -> "258 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"258 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "259 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"259 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "262 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"260 features.8.block.3.1.weight" -> "262 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"261 features.8.block.3.1.bias" -> "262 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"262 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "263 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"263 MobileNetV3/Sequential[features]/InvertedResidual[8]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "264 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0"; +"264 MobileNetV3/Sequential[features]/InvertedResidual[8]/__iadd___0" -> "265 MobileNetV3/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0"; +"265 MobileNetV3/Sequential[features]/InvertedResidual[8]/SymmetricQuantizer/symmetric_quantize_0" -> "268 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"266 features.9.block.0.0.weight" -> "267 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"267 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "268 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"268 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "271 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"269 features.9.block.0.1.weight" -> "271 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"270 features.9.block.0.1.bias" -> "271 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"271 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "272 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"272 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "273 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"273 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "276 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"274 features.9.block.1.0.weight" -> "275 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"275 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "276 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"276 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "279 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"277 features.9.block.1.1.weight" -> "279 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"278 features.9.block.1.1.bias" -> "279 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"279 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "280 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"280 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "281 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"281 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "282 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"281 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "292 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"282 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "285 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"283 features.9.block.2.fc1.weight" -> "285 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"284 features.9.block.2.fc1.bias" -> "285 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"285 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "286 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"286 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "289 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"287 features.9.block.2.fc2.weight" -> "289 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"288 features.9.block.2.fc2.bias" -> "289 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"289 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "290 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"290 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "291 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"291 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "292 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"292 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "293 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"293 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "296 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"294 features.9.block.3.0.weight" -> "295 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"295 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "296 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"296 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "299 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"297 features.9.block.3.1.weight" -> "299 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"298 features.9.block.3.1.bias" -> "299 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"299 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "300 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"300 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "303 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"300 MobileNetV3/Sequential[features]/InvertedResidual[9]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0"; +"301 features.10.block.0.0.weight" -> "302 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"302 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "303 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"303 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "306 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"304 features.10.block.0.1.weight" -> "306 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"305 features.10.block.0.1.bias" -> "306 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"306 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "307 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"307 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "308 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"308 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "311 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"309 features.10.block.1.0.weight" -> "310 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"310 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "311 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"311 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "314 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"312 features.10.block.1.1.weight" -> "314 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"313 features.10.block.1.1.bias" -> "314 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"314 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "315 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"315 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "316 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"316 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "317 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"316 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "327 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"317 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "320 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"318 features.10.block.2.fc1.weight" -> "320 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"319 features.10.block.2.fc1.bias" -> "320 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"320 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "321 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"321 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "324 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"322 features.10.block.2.fc2.weight" -> "324 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"323 features.10.block.2.fc2.bias" -> "324 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"324 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "325 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"325 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "326 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"326 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "327 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"327 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "328 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"328 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "331 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"329 features.10.block.3.0.weight" -> "330 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"330 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "331 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"331 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "334 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"332 features.10.block.3.1.weight" -> "334 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"333 features.10.block.3.1.bias" -> "334 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"334 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "335 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"335 MobileNetV3/Sequential[features]/InvertedResidual[10]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0"; +"336 MobileNetV3/Sequential[features]/InvertedResidual[10]/__iadd___0" -> "337 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0"; +"337 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" -> "340 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"337 MobileNetV3/Sequential[features]/InvertedResidual[10]/SymmetricQuantizer/symmetric_quantize_0" -> "373 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0"; +"338 features.11.block.0.0.weight" -> "339 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"339 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "340 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0"; +"340 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Conv2d[0]/conv2d_0" -> "343 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"341 features.11.block.0.1.weight" -> "343 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"342 features.11.block.0.1.bias" -> "343 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0"; +"343 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/BatchNorm2d[1]/batch_norm_0" -> "344 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0"; +"344 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/hardswish_0" -> "345 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"345 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[0]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "348 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"346 features.11.block.1.0.weight" -> "347 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"347 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "348 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0"; +"348 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Conv2d[0]/conv2d_0" -> "351 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"349 features.11.block.1.1.weight" -> "351 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"350 features.11.block.1.1.bias" -> "351 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0"; +"351 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/BatchNorm2d[1]/batch_norm_0" -> "352 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0"; +"352 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/hardswish_0" -> "353 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"353 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "354 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0"; +"353 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[1]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "364 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"354 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/adaptive_avg_pool2d_0" -> "357 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"355 features.11.block.2.fc1.weight" -> "357 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"356 features.11.block.2.fc1.bias" -> "357 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0"; +"357 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc1]/conv2d_0" -> "358 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0"; +"358 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/ReLU[relu]/relu__0" -> "361 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"359 features.11.block.2.fc2.weight" -> "361 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"360 features.11.block.2.fc2.bias" -> "361 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0"; +"361 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/Conv2d[fc2]/conv2d_0" -> "362 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0"; +"362 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/hardsigmoid_0" -> "363 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0"; +"363 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_0" -> "364 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0"; +"364 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/__mul___0" -> "365 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1"; +"365 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/SqueezeExcitation[2]/SymmetricQuantizer/symmetric_quantize_1" -> "368 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"366 features.11.block.3.0.weight" -> "367 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"367 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "368 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0"; +"368 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/Conv2d[0]/conv2d_0" -> "371 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"369 features.11.block.3.1.weight" -> "371 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"370 features.11.block.3.1.bias" -> "371 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0"; +"371 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/batch_norm_0" -> "372 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"372 MobileNetV3/Sequential[features]/InvertedResidual[11]/Sequential[block]/ConvBNActivation[3]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "373 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0"; +"373 MobileNetV3/Sequential[features]/InvertedResidual[11]/__iadd___0" -> "374 MobileNetV3/Sequential[features]/InvertedResidual[11]/SymmetricQuantizer/symmetric_quantize_0"; +"374 MobileNetV3/Sequential[features]/InvertedResidual[11]/SymmetricQuantizer/symmetric_quantize_0" -> "377 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/conv2d_0"; +"375 features.12.0.weight" -> "376 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"376 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "377 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/conv2d_0"; +"377 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Conv2d[0]/conv2d_0" -> "380 MobileNetV3/Sequential[features]/ConvBNActivation[12]/BatchNorm2d[1]/batch_norm_0"; +"378 features.12.1.weight" -> "380 MobileNetV3/Sequential[features]/ConvBNActivation[12]/BatchNorm2d[1]/batch_norm_0"; +"379 features.12.1.bias" -> "380 MobileNetV3/Sequential[features]/ConvBNActivation[12]/BatchNorm2d[1]/batch_norm_0"; +"380 MobileNetV3/Sequential[features]/ConvBNActivation[12]/BatchNorm2d[1]/batch_norm_0" -> "381 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/hardswish_0"; +"381 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/hardswish_0" -> "382 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0"; +"382 MobileNetV3/Sequential[features]/ConvBNActivation[12]/Hardswish[2]/SymmetricQuantizer/symmetric_quantize_0" -> "383 MobileNetV3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0"; +"383 MobileNetV3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" -> "384 MobileNetV3/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; +"384 MobileNetV3/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "385 MobileNetV3/flatten_0"; +"385 MobileNetV3/flatten_0" -> "389 MobileNetV3/Sequential[classifier]/Linear[0]/linear_0"; +"386 classifier.0.weight" -> "388 MobileNetV3/Sequential[classifier]/Linear[0]/SymmetricQuantizer/symmetric_quantize_0"; +"387 classifier.0.bias" -> "389 MobileNetV3/Sequential[classifier]/Linear[0]/linear_0"; +"388 MobileNetV3/Sequential[classifier]/Linear[0]/SymmetricQuantizer/symmetric_quantize_0" -> "389 MobileNetV3/Sequential[classifier]/Linear[0]/linear_0"; +"389 MobileNetV3/Sequential[classifier]/Linear[0]/linear_0" -> "390 MobileNetV3/Sequential[classifier]/Hardswish[1]/hardswish_0"; +"390 MobileNetV3/Sequential[classifier]/Hardswish[1]/hardswish_0" -> "391 MobileNetV3/Sequential[classifier]/Hardswish[1]/SymmetricQuantizer/symmetric_quantize_0"; +"391 MobileNetV3/Sequential[classifier]/Hardswish[1]/SymmetricQuantizer/symmetric_quantize_0" -> "392 MobileNetV3/Sequential[classifier]/Dropout[2]/dropout_0"; +"392 MobileNetV3/Sequential[classifier]/Dropout[2]/dropout_0" -> "396 MobileNetV3/Sequential[classifier]/Linear[3]/linear_0"; +"393 classifier.3.weight" -> "395 MobileNetV3/Sequential[classifier]/Linear[3]/SymmetricQuantizer/symmetric_quantize_0"; +"394 classifier.3.bias" -> "396 MobileNetV3/Sequential[classifier]/Linear[3]/linear_0"; +"395 MobileNetV3/Sequential[classifier]/Linear[3]/SymmetricQuantizer/symmetric_quantize_0" -> "396 MobileNetV3/Sequential[classifier]/Linear[3]/linear_0"; +"396 MobileNetV3/Sequential[classifier]/Linear[3]/linear_0" -> "397 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet18.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet18.dot index 914f7d0d66b..f9cd57e375d 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet18.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet18.dot @@ -1,253 +1,377 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 ResNet/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; -"4 ResNet/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=4, type=batch_norm]; -"5 ResNet/relu_0" [id=5, type=relu]; -"6 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 ResNet/MaxPool2d[maxpool]/max_pool2d_0" [id=7, type=max_pool2d]; -"8 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=8, type=symmetric_quantize]; -"9 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=9, type=conv2d]; -"10 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=10, type=batch_norm]; -"11 ResNet/Sequential[layer1]/BasicBlock[0]/relu_0" [id=11, type=relu]; -"12 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; -"13 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; -"14 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=14, type=conv2d]; -"15 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=15, type=batch_norm]; -"16 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0" [id=17, type=__iadd__]; -"18 ResNet/Sequential[layer1]/BasicBlock[0]/relu_1" [id=18, type=relu]; -"19 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=19, type=symmetric_quantize]; -"20 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=21, type=conv2d]; -"22 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=22, type=batch_norm]; -"23 ResNet/Sequential[layer1]/BasicBlock[1]/relu_0" [id=23, type=relu]; -"24 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=26, type=conv2d]; -"27 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=27, type=batch_norm]; -"28 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; -"29 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0" [id=29, type=__iadd__]; -"30 ResNet/Sequential[layer1]/BasicBlock[1]/relu_1" [id=30, type=relu]; -"31 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=31, type=symmetric_quantize]; -"32 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=32, type=symmetric_quantize]; -"33 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=33, type=conv2d]; -"34 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=34, type=batch_norm]; -"35 ResNet/Sequential[layer2]/BasicBlock[0]/relu_0" [id=35, type=relu]; -"36 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; -"37 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=37, type=symmetric_quantize]; -"38 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=38, type=conv2d]; -"39 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=39, type=batch_norm]; -"40 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=40, type=symmetric_quantize]; -"41 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=41, type=symmetric_quantize]; -"42 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=42, type=conv2d]; -"43 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=43, type=batch_norm]; -"44 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0" [id=45, type=__iadd__]; -"46 ResNet/Sequential[layer2]/BasicBlock[0]/relu_1" [id=46, type=relu]; -"47 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=47, type=symmetric_quantize]; -"48 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=48, type=symmetric_quantize]; -"49 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=49, type=conv2d]; -"50 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=50, type=batch_norm]; -"51 ResNet/Sequential[layer2]/BasicBlock[1]/relu_0" [id=51, type=relu]; -"52 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; -"53 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=53, type=symmetric_quantize]; -"54 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=54, type=conv2d]; -"55 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=55, type=batch_norm]; -"56 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=56, type=symmetric_quantize]; -"57 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0" [id=57, type=__iadd__]; -"58 ResNet/Sequential[layer2]/BasicBlock[1]/relu_1" [id=58, type=relu]; -"59 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=59, type=symmetric_quantize]; -"60 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=60, type=symmetric_quantize]; -"61 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=61, type=conv2d]; -"62 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=62, type=batch_norm]; -"63 ResNet/Sequential[layer3]/BasicBlock[0]/relu_0" [id=63, type=relu]; -"64 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=66, type=conv2d]; -"67 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=67, type=batch_norm]; -"68 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; -"69 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=70, type=conv2d]; -"71 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=71, type=batch_norm]; -"72 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=72, type=symmetric_quantize]; -"73 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0" [id=73, type=__iadd__]; -"74 ResNet/Sequential[layer3]/BasicBlock[0]/relu_1" [id=74, type=relu]; -"75 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=75, type=symmetric_quantize]; -"76 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=76, type=symmetric_quantize]; -"77 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=77, type=conv2d]; -"78 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=78, type=batch_norm]; -"79 ResNet/Sequential[layer3]/BasicBlock[1]/relu_0" [id=79, type=relu]; -"80 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; -"82 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=82, type=conv2d]; -"83 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=83, type=batch_norm]; -"84 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; -"85 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0" [id=85, type=__iadd__]; -"86 ResNet/Sequential[layer3]/BasicBlock[1]/relu_1" [id=86, type=relu]; -"87 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=87, type=symmetric_quantize]; -"88 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=88, type=symmetric_quantize]; -"89 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=89, type=conv2d]; -"90 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=90, type=batch_norm]; -"91 ResNet/Sequential[layer4]/BasicBlock[0]/relu_0" [id=91, type=relu]; -"92 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=92, type=symmetric_quantize]; -"93 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=93, type=symmetric_quantize]; -"94 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=94, type=conv2d]; -"95 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=95, type=batch_norm]; -"96 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=97, type=symmetric_quantize]; -"98 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=98, type=conv2d]; -"99 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=99, type=batch_norm]; -"100 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0" [id=101, type=__iadd__]; -"102 ResNet/Sequential[layer4]/BasicBlock[0]/relu_1" [id=102, type=relu]; -"103 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=103, type=symmetric_quantize]; -"104 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=104, type=symmetric_quantize]; -"105 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=105, type=conv2d]; -"106 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=106, type=batch_norm]; -"107 ResNet/Sequential[layer4]/BasicBlock[1]/relu_0" [id=107, type=relu]; -"108 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=108, type=symmetric_quantize]; -"109 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=109, type=symmetric_quantize]; -"110 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=110, type=conv2d]; -"111 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=111, type=batch_norm]; -"112 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=112, type=symmetric_quantize]; -"113 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0" [id=113, type=__iadd__]; -"114 ResNet/Sequential[layer4]/BasicBlock[1]/relu_1" [id=114, type=relu]; -"115 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=115, type=symmetric_quantize]; -"116 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" [id=116, type=adaptive_avg_pool2d]; -"117 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 ResNet/flatten_0" [id=118, type=flatten]; -"119 ResNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=119, type=symmetric_quantize]; -"120 ResNet/NNCFLinear[linear]/linear_0" [id=120, type=linear]; -"121 /nncf_model_output_0" [id=121, type=nncf_model_output]; +"2 conv1.weight" [id=2, type=nncf_model_const]; +"3 ResNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 ResNet/Conv2d[conv1]/conv2d_0" [id=4, type=conv2d]; +"5 bn1.weight" [id=5, type=nncf_model_const]; +"6 bn1.bias" [id=6, type=nncf_model_const]; +"7 ResNet/BatchNorm2d[bn1]/batch_norm_0" [id=7, type=batch_norm]; +"8 ResNet/relu_0" [id=8, type=relu]; +"9 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=9, type=symmetric_quantize]; +"10 ResNet/MaxPool2d[maxpool]/max_pool2d_0" [id=10, type=max_pool2d]; +"11 layer1.0.conv1.weight" [id=11, type=nncf_model_const]; +"12 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" [id=13, type=conv2d]; +"14 layer1.0.bn1.weight" [id=14, type=nncf_model_const]; +"15 layer1.0.bn1.bias" [id=15, type=nncf_model_const]; +"16 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=16, type=batch_norm]; +"17 ResNet/Sequential[layer1]/BasicBlock[0]/relu_0" [id=17, type=relu]; +"18 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=18, type=symmetric_quantize]; +"19 layer1.0.conv2.weight" [id=19, type=nncf_model_const]; +"20 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" [id=21, type=conv2d]; +"22 layer1.0.bn2.weight" [id=22, type=nncf_model_const]; +"23 layer1.0.bn2.bias" [id=23, type=nncf_model_const]; +"24 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=24, type=batch_norm]; +"25 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0" [id=26, type=__iadd__]; +"27 ResNet/Sequential[layer1]/BasicBlock[0]/relu_1" [id=27, type=relu]; +"28 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=28, type=symmetric_quantize]; +"29 layer1.1.conv1.weight" [id=29, type=nncf_model_const]; +"30 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=31, type=conv2d]; +"32 layer1.1.bn1.weight" [id=32, type=nncf_model_const]; +"33 layer1.1.bn1.bias" [id=33, type=nncf_model_const]; +"34 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=34, type=batch_norm]; +"35 ResNet/Sequential[layer1]/BasicBlock[1]/relu_0" [id=35, type=relu]; +"36 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; +"37 layer1.1.conv2.weight" [id=37, type=nncf_model_const]; +"38 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=39, type=conv2d]; +"40 layer1.1.bn2.weight" [id=40, type=nncf_model_const]; +"41 layer1.1.bn2.bias" [id=41, type=nncf_model_const]; +"42 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=42, type=batch_norm]; +"43 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=43, type=symmetric_quantize]; +"44 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0" [id=44, type=__iadd__]; +"45 ResNet/Sequential[layer1]/BasicBlock[1]/relu_1" [id=45, type=relu]; +"46 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=46, type=symmetric_quantize]; +"47 layer2.0.conv1.weight" [id=47, type=nncf_model_const]; +"48 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" [id=49, type=conv2d]; +"50 layer2.0.bn1.weight" [id=50, type=nncf_model_const]; +"51 layer2.0.bn1.bias" [id=51, type=nncf_model_const]; +"52 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=52, type=batch_norm]; +"53 ResNet/Sequential[layer2]/BasicBlock[0]/relu_0" [id=53, type=relu]; +"54 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; +"55 layer2.0.conv2.weight" [id=55, type=nncf_model_const]; +"56 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" [id=57, type=conv2d]; +"58 layer2.0.bn2.weight" [id=58, type=nncf_model_const]; +"59 layer2.0.bn2.bias" [id=59, type=nncf_model_const]; +"60 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=60, type=batch_norm]; +"61 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 layer2.0.shortcut.0.weight" [id=62, type=nncf_model_const]; +"63 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; +"64 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=64, type=conv2d]; +"65 layer2.0.shortcut.1.weight" [id=65, type=nncf_model_const]; +"66 layer2.0.shortcut.1.bias" [id=66, type=nncf_model_const]; +"67 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=67, type=batch_norm]; +"68 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; +"69 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0" [id=69, type=__iadd__]; +"70 ResNet/Sequential[layer2]/BasicBlock[0]/relu_1" [id=70, type=relu]; +"71 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=71, type=symmetric_quantize]; +"72 layer2.1.conv1.weight" [id=72, type=nncf_model_const]; +"73 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; +"74 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=74, type=conv2d]; +"75 layer2.1.bn1.weight" [id=75, type=nncf_model_const]; +"76 layer2.1.bn1.bias" [id=76, type=nncf_model_const]; +"77 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=77, type=batch_norm]; +"78 ResNet/Sequential[layer2]/BasicBlock[1]/relu_0" [id=78, type=relu]; +"79 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; +"80 layer2.1.conv2.weight" [id=80, type=nncf_model_const]; +"81 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=81, type=symmetric_quantize]; +"82 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=82, type=conv2d]; +"83 layer2.1.bn2.weight" [id=83, type=nncf_model_const]; +"84 layer2.1.bn2.bias" [id=84, type=nncf_model_const]; +"85 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=85, type=batch_norm]; +"86 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0" [id=87, type=__iadd__]; +"88 ResNet/Sequential[layer2]/BasicBlock[1]/relu_1" [id=88, type=relu]; +"89 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=89, type=symmetric_quantize]; +"90 layer3.0.conv1.weight" [id=90, type=nncf_model_const]; +"91 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; +"92 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" [id=92, type=conv2d]; +"93 layer3.0.bn1.weight" [id=93, type=nncf_model_const]; +"94 layer3.0.bn1.bias" [id=94, type=nncf_model_const]; +"95 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=95, type=batch_norm]; +"96 ResNet/Sequential[layer3]/BasicBlock[0]/relu_0" [id=96, type=relu]; +"97 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 layer3.0.conv2.weight" [id=98, type=nncf_model_const]; +"99 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=99, type=symmetric_quantize]; +"100 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" [id=100, type=conv2d]; +"101 layer3.0.bn2.weight" [id=101, type=nncf_model_const]; +"102 layer3.0.bn2.bias" [id=102, type=nncf_model_const]; +"103 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=103, type=batch_norm]; +"104 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=104, type=symmetric_quantize]; +"105 layer3.0.shortcut.0.weight" [id=105, type=nncf_model_const]; +"106 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=106, type=symmetric_quantize]; +"107 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=107, type=conv2d]; +"108 layer3.0.shortcut.1.weight" [id=108, type=nncf_model_const]; +"109 layer3.0.shortcut.1.bias" [id=109, type=nncf_model_const]; +"110 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=110, type=batch_norm]; +"111 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0" [id=112, type=__iadd__]; +"113 ResNet/Sequential[layer3]/BasicBlock[0]/relu_1" [id=113, type=relu]; +"114 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=114, type=symmetric_quantize]; +"115 layer3.1.conv1.weight" [id=115, type=nncf_model_const]; +"116 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=117, type=conv2d]; +"118 layer3.1.bn1.weight" [id=118, type=nncf_model_const]; +"119 layer3.1.bn1.bias" [id=119, type=nncf_model_const]; +"120 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=120, type=batch_norm]; +"121 ResNet/Sequential[layer3]/BasicBlock[1]/relu_0" [id=121, type=relu]; +"122 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; +"123 layer3.1.conv2.weight" [id=123, type=nncf_model_const]; +"124 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=124, type=symmetric_quantize]; +"125 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=125, type=conv2d]; +"126 layer3.1.bn2.weight" [id=126, type=nncf_model_const]; +"127 layer3.1.bn2.bias" [id=127, type=nncf_model_const]; +"128 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=128, type=batch_norm]; +"129 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0" [id=130, type=__iadd__]; +"131 ResNet/Sequential[layer3]/BasicBlock[1]/relu_1" [id=131, type=relu]; +"132 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=132, type=symmetric_quantize]; +"133 layer4.0.conv1.weight" [id=133, type=nncf_model_const]; +"134 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=134, type=symmetric_quantize]; +"135 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" [id=135, type=conv2d]; +"136 layer4.0.bn1.weight" [id=136, type=nncf_model_const]; +"137 layer4.0.bn1.bias" [id=137, type=nncf_model_const]; +"138 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=138, type=batch_norm]; +"139 ResNet/Sequential[layer4]/BasicBlock[0]/relu_0" [id=139, type=relu]; +"140 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 layer4.0.conv2.weight" [id=141, type=nncf_model_const]; +"142 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; +"143 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" [id=143, type=conv2d]; +"144 layer4.0.bn2.weight" [id=144, type=nncf_model_const]; +"145 layer4.0.bn2.bias" [id=145, type=nncf_model_const]; +"146 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=146, type=batch_norm]; +"147 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 layer4.0.shortcut.0.weight" [id=148, type=nncf_model_const]; +"149 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=150, type=conv2d]; +"151 layer4.0.shortcut.1.weight" [id=151, type=nncf_model_const]; +"152 layer4.0.shortcut.1.bias" [id=152, type=nncf_model_const]; +"153 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=153, type=batch_norm]; +"154 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=154, type=symmetric_quantize]; +"155 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0" [id=155, type=__iadd__]; +"156 ResNet/Sequential[layer4]/BasicBlock[0]/relu_1" [id=156, type=relu]; +"157 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=157, type=symmetric_quantize]; +"158 layer4.1.conv1.weight" [id=158, type=nncf_model_const]; +"159 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=159, type=symmetric_quantize]; +"160 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=160, type=conv2d]; +"161 layer4.1.bn1.weight" [id=161, type=nncf_model_const]; +"162 layer4.1.bn1.bias" [id=162, type=nncf_model_const]; +"163 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=163, type=batch_norm]; +"164 ResNet/Sequential[layer4]/BasicBlock[1]/relu_0" [id=164, type=relu]; +"165 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=165, type=symmetric_quantize]; +"166 layer4.1.conv2.weight" [id=166, type=nncf_model_const]; +"167 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; +"168 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=168, type=conv2d]; +"169 layer4.1.bn2.weight" [id=169, type=nncf_model_const]; +"170 layer4.1.bn2.bias" [id=170, type=nncf_model_const]; +"171 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=171, type=batch_norm]; +"172 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=172, type=symmetric_quantize]; +"173 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0" [id=173, type=__iadd__]; +"174 ResNet/Sequential[layer4]/BasicBlock[1]/relu_1" [id=174, type=relu]; +"175 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=175, type=symmetric_quantize]; +"176 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" [id=176, type=adaptive_avg_pool2d]; +"177 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; +"178 ResNet/flatten_0" [id=178, type=flatten]; +"179 linear.weight" [id=179, type=nncf_model_const]; +"180 linear.bias" [id=180, type=nncf_model_const]; +"181 ResNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" [id=181, type=symmetric_quantize]; +"182 ResNet/Linear[linear]/linear_0" [id=182, type=linear]; +"183 /nncf_model_output_0" [id=183, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 ResNet/NNCFConv2d[conv1]/conv2d_0"; -"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 ResNet/NNCFConv2d[conv1]/conv2d_0"; -"3 ResNet/NNCFConv2d[conv1]/conv2d_0" -> "4 ResNet/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"4 ResNet/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "5 ResNet/relu_0"; -"5 ResNet/relu_0" -> "6 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0"; -"6 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d_0"; -"7 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "9 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"7 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "17 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0"; -"8 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "9 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"9 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "10 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"10 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "11 ResNet/Sequential[layer1]/BasicBlock[0]/relu_0"; -"11 ResNet/Sequential[layer1]/BasicBlock[0]/relu_0" -> "12 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"12 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "14 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"13 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"14 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "15 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"15 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "16 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"16 ResNet/Sequential[layer1]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "17 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0"; -"17 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0" -> "18 ResNet/Sequential[layer1]/BasicBlock[0]/relu_1"; -"18 ResNet/Sequential[layer1]/BasicBlock[0]/relu_1" -> "19 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"19 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "21 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"19 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "29 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0"; -"20 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"21 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "22 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"22 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "23 ResNet/Sequential[layer1]/BasicBlock[1]/relu_0"; -"23 ResNet/Sequential[layer1]/BasicBlock[1]/relu_0" -> "24 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"24 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "26 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"25 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "26 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"26 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "27 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"27 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "28 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"28 ResNet/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "29 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0"; -"29 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0" -> "30 ResNet/Sequential[layer1]/BasicBlock[1]/relu_1"; -"30 ResNet/Sequential[layer1]/BasicBlock[1]/relu_1" -> "31 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"31 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "33 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"31 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "42 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"32 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "33 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"33 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "34 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"34 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "35 ResNet/Sequential[layer2]/BasicBlock[0]/relu_0"; -"35 ResNet/Sequential[layer2]/BasicBlock[0]/relu_0" -> "36 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"36 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "38 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"37 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "38 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"38 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "39 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"39 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "40 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"40 ResNet/Sequential[layer2]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "45 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0"; -"41 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "42 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"42 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "43 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"43 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "44 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"44 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "45 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0"; -"45 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0" -> "46 ResNet/Sequential[layer2]/BasicBlock[0]/relu_1"; -"46 ResNet/Sequential[layer2]/BasicBlock[0]/relu_1" -> "47 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"47 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "49 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"47 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "57 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0"; -"48 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "49 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"49 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "50 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"50 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "51 ResNet/Sequential[layer2]/BasicBlock[1]/relu_0"; -"51 ResNet/Sequential[layer2]/BasicBlock[1]/relu_0" -> "52 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"52 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "54 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"53 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "54 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"54 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "55 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"55 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "56 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"56 ResNet/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "57 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0"; -"57 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0" -> "58 ResNet/Sequential[layer2]/BasicBlock[1]/relu_1"; -"58 ResNet/Sequential[layer2]/BasicBlock[1]/relu_1" -> "59 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"59 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "61 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"59 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "70 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"60 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "61 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"61 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "62 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"62 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "63 ResNet/Sequential[layer3]/BasicBlock[0]/relu_0"; -"63 ResNet/Sequential[layer3]/BasicBlock[0]/relu_0" -> "64 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"64 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "66 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"65 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"66 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "67 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"67 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "68 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"68 ResNet/Sequential[layer3]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "73 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0"; -"69 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "70 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"70 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "71 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"71 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "72 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"72 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "73 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0"; -"73 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0" -> "74 ResNet/Sequential[layer3]/BasicBlock[0]/relu_1"; -"74 ResNet/Sequential[layer3]/BasicBlock[0]/relu_1" -> "75 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"75 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "77 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"75 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "85 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0"; -"76 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "77 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"77 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "78 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"78 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "79 ResNet/Sequential[layer3]/BasicBlock[1]/relu_0"; -"79 ResNet/Sequential[layer3]/BasicBlock[1]/relu_0" -> "80 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"80 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "82 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"81 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"82 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "83 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"83 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "84 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"84 ResNet/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "85 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0"; -"85 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0" -> "86 ResNet/Sequential[layer3]/BasicBlock[1]/relu_1"; -"86 ResNet/Sequential[layer3]/BasicBlock[1]/relu_1" -> "87 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"87 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "89 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"87 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "98 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"88 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "89 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"89 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "90 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"90 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "91 ResNet/Sequential[layer4]/BasicBlock[0]/relu_0"; -"91 ResNet/Sequential[layer4]/BasicBlock[0]/relu_0" -> "92 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"92 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "94 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"93 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "94 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"94 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "95 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"95 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "96 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"96 ResNet/Sequential[layer4]/BasicBlock[0]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "101 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0"; -"97 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "98 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"98 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "99 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"99 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "100 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"100 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "101 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0"; -"101 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0" -> "102 ResNet/Sequential[layer4]/BasicBlock[0]/relu_1"; -"102 ResNet/Sequential[layer4]/BasicBlock[0]/relu_1" -> "103 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"103 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "105 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"103 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "113 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0"; -"104 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "105 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"105 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "106 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"106 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "107 ResNet/Sequential[layer4]/BasicBlock[1]/relu_0"; -"107 ResNet/Sequential[layer4]/BasicBlock[1]/relu_0" -> "108 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"108 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "110 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"109 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "110 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"110 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "111 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"111 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "112 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"112 ResNet/Sequential[layer4]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "113 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0"; -"113 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0" -> "114 ResNet/Sequential[layer4]/BasicBlock[1]/relu_1"; -"114 ResNet/Sequential[layer4]/BasicBlock[1]/relu_1" -> "115 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"115 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "116 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0"; -"116 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" -> "117 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; -"117 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "118 ResNet/flatten_0"; -"118 ResNet/flatten_0" -> "120 ResNet/NNCFLinear[linear]/linear_0"; -"119 ResNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "120 ResNet/NNCFLinear[linear]/linear_0"; -"120 ResNet/NNCFLinear[linear]/linear_0" -> "121 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "4 ResNet/Conv2d[conv1]/conv2d_0"; +"2 conv1.weight" -> "3 ResNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"3 ResNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "4 ResNet/Conv2d[conv1]/conv2d_0"; +"4 ResNet/Conv2d[conv1]/conv2d_0" -> "7 ResNet/BatchNorm2d[bn1]/batch_norm_0"; +"5 bn1.weight" -> "7 ResNet/BatchNorm2d[bn1]/batch_norm_0"; +"6 bn1.bias" -> "7 ResNet/BatchNorm2d[bn1]/batch_norm_0"; +"7 ResNet/BatchNorm2d[bn1]/batch_norm_0" -> "8 ResNet/relu_0"; +"8 ResNet/relu_0" -> "9 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0"; +"9 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "10 ResNet/MaxPool2d[maxpool]/max_pool2d_0"; +"10 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "13 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"10 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "26 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0"; +"11 layer1.0.conv1.weight" -> "12 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"12 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "13 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"13 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" -> "16 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"14 layer1.0.bn1.weight" -> "16 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"15 layer1.0.bn1.bias" -> "16 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"16 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "17 ResNet/Sequential[layer1]/BasicBlock[0]/relu_0"; +"17 ResNet/Sequential[layer1]/BasicBlock[0]/relu_0" -> "18 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"18 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "21 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"19 layer1.0.conv2.weight" -> "20 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"20 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "21 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"21 ResNet/Sequential[layer1]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" -> "24 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"22 layer1.0.bn2.weight" -> "24 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"23 layer1.0.bn2.bias" -> "24 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"24 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "25 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"25 ResNet/Sequential[layer1]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "26 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0"; +"26 ResNet/Sequential[layer1]/BasicBlock[0]/__iadd___0" -> "27 ResNet/Sequential[layer1]/BasicBlock[0]/relu_1"; +"27 ResNet/Sequential[layer1]/BasicBlock[0]/relu_1" -> "28 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"28 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "31 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"28 ResNet/Sequential[layer1]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "44 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0"; +"29 layer1.1.conv1.weight" -> "30 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"30 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "31 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"31 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "34 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"32 layer1.1.bn1.weight" -> "34 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"33 layer1.1.bn1.bias" -> "34 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"34 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "35 ResNet/Sequential[layer1]/BasicBlock[1]/relu_0"; +"35 ResNet/Sequential[layer1]/BasicBlock[1]/relu_0" -> "36 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"36 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "39 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"37 layer1.1.conv2.weight" -> "38 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"38 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "39 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"39 ResNet/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "42 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"40 layer1.1.bn2.weight" -> "42 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"41 layer1.1.bn2.bias" -> "42 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"42 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "43 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"43 ResNet/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "44 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0"; +"44 ResNet/Sequential[layer1]/BasicBlock[1]/__iadd___0" -> "45 ResNet/Sequential[layer1]/BasicBlock[1]/relu_1"; +"45 ResNet/Sequential[layer1]/BasicBlock[1]/relu_1" -> "46 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"46 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "49 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"46 ResNet/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "64 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"47 layer2.0.conv1.weight" -> "48 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"48 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "49 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"49 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" -> "52 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"50 layer2.0.bn1.weight" -> "52 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"51 layer2.0.bn1.bias" -> "52 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"52 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "53 ResNet/Sequential[layer2]/BasicBlock[0]/relu_0"; +"53 ResNet/Sequential[layer2]/BasicBlock[0]/relu_0" -> "54 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"54 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "57 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"55 layer2.0.conv2.weight" -> "56 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"56 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "57 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"57 ResNet/Sequential[layer2]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" -> "60 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"58 layer2.0.bn2.weight" -> "60 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"59 layer2.0.bn2.bias" -> "60 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"60 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "61 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"61 ResNet/Sequential[layer2]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "69 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0"; +"62 layer2.0.shortcut.0.weight" -> "63 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"63 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "64 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"64 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "67 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"65 layer2.0.shortcut.1.weight" -> "67 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"66 layer2.0.shortcut.1.bias" -> "67 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"67 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "68 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"68 ResNet/Sequential[layer2]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "69 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0"; +"69 ResNet/Sequential[layer2]/BasicBlock[0]/__iadd___0" -> "70 ResNet/Sequential[layer2]/BasicBlock[0]/relu_1"; +"70 ResNet/Sequential[layer2]/BasicBlock[0]/relu_1" -> "71 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"71 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "74 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"71 ResNet/Sequential[layer2]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "87 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0"; +"72 layer2.1.conv1.weight" -> "73 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"73 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "74 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"74 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "77 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"75 layer2.1.bn1.weight" -> "77 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"76 layer2.1.bn1.bias" -> "77 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"77 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "78 ResNet/Sequential[layer2]/BasicBlock[1]/relu_0"; +"78 ResNet/Sequential[layer2]/BasicBlock[1]/relu_0" -> "79 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"79 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "82 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"80 layer2.1.conv2.weight" -> "81 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"81 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "82 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"82 ResNet/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "85 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"83 layer2.1.bn2.weight" -> "85 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"84 layer2.1.bn2.bias" -> "85 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"85 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "86 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"86 ResNet/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "87 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0"; +"87 ResNet/Sequential[layer2]/BasicBlock[1]/__iadd___0" -> "88 ResNet/Sequential[layer2]/BasicBlock[1]/relu_1"; +"88 ResNet/Sequential[layer2]/BasicBlock[1]/relu_1" -> "89 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"89 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "92 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"89 ResNet/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "107 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"90 layer3.0.conv1.weight" -> "91 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"91 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "92 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"92 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" -> "95 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"93 layer3.0.bn1.weight" -> "95 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"94 layer3.0.bn1.bias" -> "95 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"95 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "96 ResNet/Sequential[layer3]/BasicBlock[0]/relu_0"; +"96 ResNet/Sequential[layer3]/BasicBlock[0]/relu_0" -> "97 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"97 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "100 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"98 layer3.0.conv2.weight" -> "99 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"99 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "100 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"100 ResNet/Sequential[layer3]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" -> "103 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"101 layer3.0.bn2.weight" -> "103 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"102 layer3.0.bn2.bias" -> "103 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"103 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "104 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"104 ResNet/Sequential[layer3]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "112 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0"; +"105 layer3.0.shortcut.0.weight" -> "106 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"106 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "107 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"107 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "110 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"108 layer3.0.shortcut.1.weight" -> "110 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"109 layer3.0.shortcut.1.bias" -> "110 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"110 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "111 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"111 ResNet/Sequential[layer3]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "112 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0"; +"112 ResNet/Sequential[layer3]/BasicBlock[0]/__iadd___0" -> "113 ResNet/Sequential[layer3]/BasicBlock[0]/relu_1"; +"113 ResNet/Sequential[layer3]/BasicBlock[0]/relu_1" -> "114 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"114 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "117 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"114 ResNet/Sequential[layer3]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "130 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0"; +"115 layer3.1.conv1.weight" -> "116 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"116 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "117 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"117 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "120 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"118 layer3.1.bn1.weight" -> "120 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"119 layer3.1.bn1.bias" -> "120 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"120 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "121 ResNet/Sequential[layer3]/BasicBlock[1]/relu_0"; +"121 ResNet/Sequential[layer3]/BasicBlock[1]/relu_0" -> "122 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"122 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "125 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"123 layer3.1.conv2.weight" -> "124 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"124 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "125 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"125 ResNet/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "128 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"126 layer3.1.bn2.weight" -> "128 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"127 layer3.1.bn2.bias" -> "128 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"128 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "129 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"129 ResNet/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "130 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0"; +"130 ResNet/Sequential[layer3]/BasicBlock[1]/__iadd___0" -> "131 ResNet/Sequential[layer3]/BasicBlock[1]/relu_1"; +"131 ResNet/Sequential[layer3]/BasicBlock[1]/relu_1" -> "132 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"132 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "135 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"132 ResNet/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "150 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"133 layer4.0.conv1.weight" -> "134 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"134 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "135 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/conv2d_0"; +"135 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv1]/conv2d_0" -> "138 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"136 layer4.0.bn1.weight" -> "138 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"137 layer4.0.bn1.bias" -> "138 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"138 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "139 ResNet/Sequential[layer4]/BasicBlock[0]/relu_0"; +"139 ResNet/Sequential[layer4]/BasicBlock[0]/relu_0" -> "140 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"140 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "143 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"141 layer4.0.conv2.weight" -> "142 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"142 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "143 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/conv2d_0"; +"143 ResNet/Sequential[layer4]/BasicBlock[0]/Conv2d[conv2]/conv2d_0" -> "146 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"144 layer4.0.bn2.weight" -> "146 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"145 layer4.0.bn2.bias" -> "146 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"146 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "147 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"147 ResNet/Sequential[layer4]/BasicBlock[0]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "155 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0"; +"148 layer4.0.shortcut.0.weight" -> "149 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"149 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "150 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"150 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "153 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"151 layer4.0.shortcut.1.weight" -> "153 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"152 layer4.0.shortcut.1.bias" -> "153 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"153 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "154 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"154 ResNet/Sequential[layer4]/BasicBlock[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "155 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0"; +"155 ResNet/Sequential[layer4]/BasicBlock[0]/__iadd___0" -> "156 ResNet/Sequential[layer4]/BasicBlock[0]/relu_1"; +"156 ResNet/Sequential[layer4]/BasicBlock[0]/relu_1" -> "157 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"157 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "160 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"157 ResNet/Sequential[layer4]/BasicBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "173 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0"; +"158 layer4.1.conv1.weight" -> "159 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"159 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "160 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"160 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "163 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"161 layer4.1.bn1.weight" -> "163 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"162 layer4.1.bn1.bias" -> "163 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"163 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "164 ResNet/Sequential[layer4]/BasicBlock[1]/relu_0"; +"164 ResNet/Sequential[layer4]/BasicBlock[1]/relu_0" -> "165 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"165 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "168 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"166 layer4.1.conv2.weight" -> "167 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"167 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "168 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"168 ResNet/Sequential[layer4]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "171 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"169 layer4.1.bn2.weight" -> "171 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"170 layer4.1.bn2.bias" -> "171 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"171 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "172 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"172 ResNet/Sequential[layer4]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "173 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0"; +"173 ResNet/Sequential[layer4]/BasicBlock[1]/__iadd___0" -> "174 ResNet/Sequential[layer4]/BasicBlock[1]/relu_1"; +"174 ResNet/Sequential[layer4]/BasicBlock[1]/relu_1" -> "175 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"175 ResNet/Sequential[layer4]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "176 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0"; +"176 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" -> "177 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; +"177 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "178 ResNet/flatten_0"; +"178 ResNet/flatten_0" -> "182 ResNet/Linear[linear]/linear_0"; +"179 linear.weight" -> "181 ResNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0"; +"180 linear.bias" -> "182 ResNet/Linear[linear]/linear_0"; +"181 ResNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" -> "182 ResNet/Linear[linear]/linear_0"; +"182 ResNet/Linear[linear]/linear_0" -> "183 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet50_cpu_spr.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet50_cpu_spr.dot index 9f928773f4a..e3853c814fa 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet50_cpu_spr.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/resnet50_cpu_spr.dot @@ -1,589 +1,911 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 ResNet/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; -"4 ResNet/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=4, type=batch_norm]; -"5 ResNet/relu_0" [id=5, type=relu]; -"6 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 ResNet/MaxPool2d[maxpool]/max_pool2d_0" [id=7, type=max_pool2d]; -"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=8, type=symmetric_quantize]; -"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=9, type=conv2d]; -"10 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=10, type=batch_norm]; -"11 ResNet/Sequential[layer1]/Bottleneck[0]/relu_0" [id=11, type=relu]; -"12 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; -"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; -"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=14, type=conv2d]; -"15 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=15, type=batch_norm]; -"16 ResNet/Sequential[layer1]/Bottleneck[0]/relu_1" [id=16, type=relu]; -"17 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=17, type=symmetric_quantize]; -"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=18, type=symmetric_quantize]; -"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=19, type=conv2d]; -"20 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=20, type=batch_norm]; -"21 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=22, type=conv2d]; -"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=23, type=batch_norm]; -"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0" [id=25, type=__iadd__]; -"26 ResNet/Sequential[layer1]/Bottleneck[0]/relu_2" [id=26, type=relu]; -"27 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=27, type=symmetric_quantize]; -"28 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=28, type=symmetric_quantize]; -"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=29, type=conv2d]; -"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=30, type=batch_norm]; -"31 ResNet/Sequential[layer1]/Bottleneck[1]/relu_0" [id=31, type=relu]; -"32 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=32, type=symmetric_quantize]; -"33 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=33, type=symmetric_quantize]; -"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=34, type=conv2d]; -"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=35, type=batch_norm]; -"36 ResNet/Sequential[layer1]/Bottleneck[1]/relu_1" [id=36, type=relu]; -"37 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=37, type=symmetric_quantize]; -"38 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=38, type=symmetric_quantize]; -"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=39, type=conv2d]; -"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=40, type=batch_norm]; -"41 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0" [id=41, type=__iadd__]; -"42 ResNet/Sequential[layer1]/Bottleneck[1]/relu_2" [id=42, type=relu]; -"43 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=43, type=symmetric_quantize]; -"44 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=45, type=conv2d]; -"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=46, type=batch_norm]; -"47 ResNet/Sequential[layer1]/Bottleneck[2]/relu_0" [id=47, type=relu]; -"48 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; -"49 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=49, type=symmetric_quantize]; -"50 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=50, type=conv2d]; -"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=51, type=batch_norm]; -"52 ResNet/Sequential[layer1]/Bottleneck[2]/relu_1" [id=52, type=relu]; -"53 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=53, type=symmetric_quantize]; -"54 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=54, type=symmetric_quantize]; -"55 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=55, type=conv2d]; -"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=56, type=batch_norm]; -"57 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0" [id=57, type=__iadd__]; -"58 ResNet/Sequential[layer1]/Bottleneck[2]/relu_2" [id=58, type=relu]; -"59 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=59, type=symmetric_quantize]; -"60 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=60, type=symmetric_quantize]; -"61 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=61, type=conv2d]; -"62 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=62, type=batch_norm]; -"63 ResNet/Sequential[layer2]/Bottleneck[0]/relu_0" [id=63, type=relu]; -"64 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=66, type=conv2d]; -"67 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=67, type=batch_norm]; -"68 ResNet/Sequential[layer2]/Bottleneck[0]/relu_1" [id=68, type=relu]; -"69 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=69, type=symmetric_quantize]; -"70 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=70, type=symmetric_quantize]; -"71 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=71, type=conv2d]; -"72 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=72, type=batch_norm]; -"73 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=74, type=conv2d]; -"75 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=75, type=batch_norm]; -"76 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; -"77 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0" [id=77, type=__iadd__]; -"78 ResNet/Sequential[layer2]/Bottleneck[0]/relu_2" [id=78, type=relu]; -"79 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=79, type=symmetric_quantize]; -"80 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=81, type=conv2d]; -"82 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=82, type=batch_norm]; -"83 ResNet/Sequential[layer2]/Bottleneck[1]/relu_0" [id=83, type=relu]; -"84 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; -"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=86, type=conv2d]; -"87 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=87, type=batch_norm]; -"88 ResNet/Sequential[layer2]/Bottleneck[1]/relu_1" [id=88, type=relu]; -"89 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=89, type=symmetric_quantize]; -"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=90, type=symmetric_quantize]; -"91 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=91, type=conv2d]; -"92 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=92, type=batch_norm]; -"93 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0" [id=93, type=__iadd__]; -"94 ResNet/Sequential[layer2]/Bottleneck[1]/relu_2" [id=94, type=relu]; -"95 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=95, type=symmetric_quantize]; -"96 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=97, type=conv2d]; -"98 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=98, type=batch_norm]; -"99 ResNet/Sequential[layer2]/Bottleneck[2]/relu_0" [id=99, type=relu]; -"100 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=101, type=symmetric_quantize]; -"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=102, type=conv2d]; -"103 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=103, type=batch_norm]; -"104 ResNet/Sequential[layer2]/Bottleneck[2]/relu_1" [id=104, type=relu]; -"105 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=105, type=symmetric_quantize]; -"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=106, type=symmetric_quantize]; -"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=107, type=conv2d]; -"108 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=108, type=batch_norm]; -"109 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0" [id=109, type=__iadd__]; -"110 ResNet/Sequential[layer2]/Bottleneck[2]/relu_2" [id=110, type=relu]; -"111 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=111, type=symmetric_quantize]; -"112 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=112, type=symmetric_quantize]; -"113 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=113, type=conv2d]; -"114 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=114, type=batch_norm]; -"115 ResNet/Sequential[layer2]/Bottleneck[3]/relu_0" [id=115, type=relu]; -"116 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; -"117 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=118, type=conv2d]; -"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=119, type=batch_norm]; -"120 ResNet/Sequential[layer2]/Bottleneck[3]/relu_1" [id=120, type=relu]; -"121 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=121, type=symmetric_quantize]; -"122 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=122, type=symmetric_quantize]; -"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" [id=123, type=conv2d]; -"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=124, type=batch_norm]; -"125 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0" [id=125, type=__iadd__]; -"126 ResNet/Sequential[layer2]/Bottleneck[3]/relu_2" [id=126, type=relu]; -"127 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" [id=127, type=symmetric_quantize]; -"128 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=128, type=symmetric_quantize]; -"129 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=129, type=conv2d]; -"130 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=130, type=batch_norm]; -"131 ResNet/Sequential[layer3]/Bottleneck[0]/relu_0" [id=131, type=relu]; -"132 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=132, type=symmetric_quantize]; -"133 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=133, type=symmetric_quantize]; -"134 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=134, type=conv2d]; -"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=135, type=batch_norm]; -"136 ResNet/Sequential[layer3]/Bottleneck[0]/relu_1" [id=136, type=relu]; -"137 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=137, type=symmetric_quantize]; -"138 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=138, type=symmetric_quantize]; -"139 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=139, type=conv2d]; -"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=140, type=batch_norm]; -"141 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=141, type=symmetric_quantize]; -"142 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=142, type=conv2d]; -"143 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=143, type=batch_norm]; -"144 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=144, type=symmetric_quantize]; -"145 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0" [id=145, type=__iadd__]; -"146 ResNet/Sequential[layer3]/Bottleneck[0]/relu_2" [id=146, type=relu]; -"147 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=147, type=symmetric_quantize]; -"148 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=149, type=conv2d]; -"150 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=150, type=batch_norm]; -"151 ResNet/Sequential[layer3]/Bottleneck[1]/relu_0" [id=151, type=relu]; -"152 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=152, type=symmetric_quantize]; -"153 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=153, type=symmetric_quantize]; -"154 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=154, type=conv2d]; -"155 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=155, type=batch_norm]; -"156 ResNet/Sequential[layer3]/Bottleneck[1]/relu_1" [id=156, type=relu]; -"157 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=157, type=symmetric_quantize]; -"158 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=158, type=symmetric_quantize]; -"159 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=159, type=conv2d]; -"160 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=160, type=batch_norm]; -"161 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0" [id=161, type=__iadd__]; -"162 ResNet/Sequential[layer3]/Bottleneck[1]/relu_2" [id=162, type=relu]; -"163 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=163, type=symmetric_quantize]; -"164 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=164, type=symmetric_quantize]; -"165 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=165, type=conv2d]; -"166 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=166, type=batch_norm]; -"167 ResNet/Sequential[layer3]/Bottleneck[2]/relu_0" [id=167, type=relu]; -"168 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=168, type=symmetric_quantize]; -"169 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=169, type=symmetric_quantize]; -"170 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=170, type=conv2d]; -"171 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=171, type=batch_norm]; -"172 ResNet/Sequential[layer3]/Bottleneck[2]/relu_1" [id=172, type=relu]; -"173 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=173, type=symmetric_quantize]; -"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=174, type=symmetric_quantize]; -"175 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=175, type=conv2d]; -"176 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=176, type=batch_norm]; -"177 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0" [id=177, type=__iadd__]; -"178 ResNet/Sequential[layer3]/Bottleneck[2]/relu_2" [id=178, type=relu]; -"179 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=179, type=symmetric_quantize]; -"180 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=180, type=symmetric_quantize]; -"181 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=181, type=conv2d]; -"182 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=182, type=batch_norm]; -"183 ResNet/Sequential[layer3]/Bottleneck[3]/relu_0" [id=183, type=relu]; -"184 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=184, type=symmetric_quantize]; -"185 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=185, type=symmetric_quantize]; -"186 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=186, type=conv2d]; -"187 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=187, type=batch_norm]; -"188 ResNet/Sequential[layer3]/Bottleneck[3]/relu_1" [id=188, type=relu]; -"189 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=189, type=symmetric_quantize]; -"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=190, type=symmetric_quantize]; -"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" [id=191, type=conv2d]; -"192 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=192, type=batch_norm]; -"193 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0" [id=193, type=__iadd__]; -"194 ResNet/Sequential[layer3]/Bottleneck[3]/relu_2" [id=194, type=relu]; -"195 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" [id=195, type=symmetric_quantize]; -"196 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=196, type=symmetric_quantize]; -"197 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=197, type=conv2d]; -"198 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=198, type=batch_norm]; -"199 ResNet/Sequential[layer3]/Bottleneck[4]/relu_0" [id=199, type=relu]; -"200 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=200, type=symmetric_quantize]; -"201 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=201, type=symmetric_quantize]; -"202 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=202, type=conv2d]; -"203 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=203, type=batch_norm]; -"204 ResNet/Sequential[layer3]/Bottleneck[4]/relu_1" [id=204, type=relu]; -"205 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=205, type=symmetric_quantize]; -"206 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=206, type=symmetric_quantize]; -"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0" [id=207, type=conv2d]; -"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=208, type=batch_norm]; -"209 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0" [id=209, type=__iadd__]; -"210 ResNet/Sequential[layer3]/Bottleneck[4]/relu_2" [id=210, type=relu]; -"211 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2" [id=211, type=symmetric_quantize]; -"212 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=212, type=symmetric_quantize]; -"213 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=213, type=conv2d]; -"214 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=214, type=batch_norm]; -"215 ResNet/Sequential[layer3]/Bottleneck[5]/relu_0" [id=215, type=relu]; -"216 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=216, type=symmetric_quantize]; -"217 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=217, type=symmetric_quantize]; -"218 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=218, type=conv2d]; -"219 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=219, type=batch_norm]; -"220 ResNet/Sequential[layer3]/Bottleneck[5]/relu_1" [id=220, type=relu]; -"221 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=221, type=symmetric_quantize]; -"222 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=222, type=symmetric_quantize]; -"223 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0" [id=223, type=conv2d]; -"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=224, type=batch_norm]; -"225 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0" [id=225, type=__iadd__]; -"226 ResNet/Sequential[layer3]/Bottleneck[5]/relu_2" [id=226, type=relu]; -"227 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2" [id=227, type=symmetric_quantize]; -"228 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=228, type=symmetric_quantize]; -"229 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=229, type=conv2d]; -"230 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=230, type=batch_norm]; -"231 ResNet/Sequential[layer4]/Bottleneck[0]/relu_0" [id=231, type=relu]; -"232 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=232, type=symmetric_quantize]; -"233 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=233, type=symmetric_quantize]; -"234 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=234, type=conv2d]; -"235 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=235, type=batch_norm]; -"236 ResNet/Sequential[layer4]/Bottleneck[0]/relu_1" [id=236, type=relu]; -"237 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=237, type=symmetric_quantize]; -"238 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=238, type=symmetric_quantize]; -"239 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=239, type=conv2d]; -"240 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=240, type=batch_norm]; -"241 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=241, type=symmetric_quantize]; -"242 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" [id=242, type=conv2d]; -"243 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" [id=243, type=batch_norm]; -"244 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; -"245 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0" [id=245, type=__iadd__]; -"246 ResNet/Sequential[layer4]/Bottleneck[0]/relu_2" [id=246, type=relu]; -"247 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=247, type=symmetric_quantize]; -"248 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=248, type=symmetric_quantize]; -"249 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=249, type=conv2d]; -"250 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=250, type=batch_norm]; -"251 ResNet/Sequential[layer4]/Bottleneck[1]/relu_0" [id=251, type=relu]; -"252 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=252, type=symmetric_quantize]; -"253 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=253, type=symmetric_quantize]; -"254 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=254, type=conv2d]; -"255 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=255, type=batch_norm]; -"256 ResNet/Sequential[layer4]/Bottleneck[1]/relu_1" [id=256, type=relu]; -"257 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=257, type=symmetric_quantize]; -"258 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=258, type=symmetric_quantize]; -"259 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=259, type=conv2d]; -"260 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=260, type=batch_norm]; -"261 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0" [id=261, type=__iadd__]; -"262 ResNet/Sequential[layer4]/Bottleneck[1]/relu_2" [id=262, type=relu]; -"263 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=263, type=symmetric_quantize]; -"264 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=264, type=symmetric_quantize]; -"265 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=265, type=conv2d]; -"266 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=266, type=batch_norm]; -"267 ResNet/Sequential[layer4]/Bottleneck[2]/relu_0" [id=267, type=relu]; -"268 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=268, type=symmetric_quantize]; -"269 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=269, type=symmetric_quantize]; -"270 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=270, type=conv2d]; -"271 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=271, type=batch_norm]; -"272 ResNet/Sequential[layer4]/Bottleneck[2]/relu_1" [id=272, type=relu]; -"273 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=273, type=symmetric_quantize]; -"274 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=274, type=symmetric_quantize]; -"275 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=275, type=conv2d]; -"276 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=276, type=batch_norm]; -"277 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0" [id=277, type=__iadd__]; -"278 ResNet/Sequential[layer4]/Bottleneck[2]/relu_2" [id=278, type=relu]; -"279 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=279, type=symmetric_quantize]; -"280 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" [id=280, type=adaptive_avg_pool2d]; -"281 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=281, type=symmetric_quantize]; -"282 ResNet/flatten_0" [id=282, type=flatten]; -"283 ResNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=283, type=symmetric_quantize]; -"284 ResNet/NNCFLinear[linear]/linear_0" [id=284, type=linear]; -"285 /nncf_model_output_0" [id=285, type=nncf_model_output]; +"2 conv1.weight" [id=2, type=nncf_model_const]; +"3 ResNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 ResNet/Conv2d[conv1]/conv2d_0" [id=4, type=conv2d]; +"5 bn1.weight" [id=5, type=nncf_model_const]; +"6 bn1.bias" [id=6, type=nncf_model_const]; +"7 ResNet/BatchNorm2d[bn1]/batch_norm_0" [id=7, type=batch_norm]; +"8 ResNet/relu_0" [id=8, type=relu]; +"9 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" [id=9, type=symmetric_quantize]; +"10 ResNet/MaxPool2d[maxpool]/max_pool2d_0" [id=10, type=max_pool2d]; +"11 layer1.0.conv1.weight" [id=11, type=nncf_model_const]; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=13, type=conv2d]; +"14 layer1.0.bn1.weight" [id=14, type=nncf_model_const]; +"15 layer1.0.bn1.bias" [id=15, type=nncf_model_const]; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=16, type=batch_norm]; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/relu_0" [id=17, type=relu]; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=18, type=symmetric_quantize]; +"19 layer1.0.conv2.weight" [id=19, type=nncf_model_const]; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=21, type=conv2d]; +"22 layer1.0.bn2.weight" [id=22, type=nncf_model_const]; +"23 layer1.0.bn2.bias" [id=23, type=nncf_model_const]; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=24, type=batch_norm]; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/relu_1" [id=25, type=relu]; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=26, type=symmetric_quantize]; +"27 layer1.0.conv3.weight" [id=27, type=nncf_model_const]; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; +"29 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" [id=29, type=conv2d]; +"30 layer1.0.bn3.weight" [id=30, type=nncf_model_const]; +"31 layer1.0.bn3.bias" [id=31, type=nncf_model_const]; +"32 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" [id=32, type=batch_norm]; +"33 layer1.0.shortcut.0.weight" [id=33, type=nncf_model_const]; +"34 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=35, type=conv2d]; +"36 layer1.0.shortcut.1.weight" [id=36, type=nncf_model_const]; +"37 layer1.0.shortcut.1.bias" [id=37, type=nncf_model_const]; +"38 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=38, type=batch_norm]; +"39 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0" [id=40, type=__iadd__]; +"41 ResNet/Sequential[layer1]/Bottleneck[0]/relu_2" [id=41, type=relu]; +"42 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=42, type=symmetric_quantize]; +"43 layer1.1.conv1.weight" [id=43, type=nncf_model_const]; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=45, type=conv2d]; +"46 layer1.1.bn1.weight" [id=46, type=nncf_model_const]; +"47 layer1.1.bn1.bias" [id=47, type=nncf_model_const]; +"48 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=48, type=batch_norm]; +"49 ResNet/Sequential[layer1]/Bottleneck[1]/relu_0" [id=49, type=relu]; +"50 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; +"51 layer1.1.conv2.weight" [id=51, type=nncf_model_const]; +"52 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; +"53 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=53, type=conv2d]; +"54 layer1.1.bn2.weight" [id=54, type=nncf_model_const]; +"55 layer1.1.bn2.bias" [id=55, type=nncf_model_const]; +"56 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=56, type=batch_norm]; +"57 ResNet/Sequential[layer1]/Bottleneck[1]/relu_1" [id=57, type=relu]; +"58 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=58, type=symmetric_quantize]; +"59 layer1.1.conv3.weight" [id=59, type=nncf_model_const]; +"60 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" [id=61, type=conv2d]; +"62 layer1.1.bn3.weight" [id=62, type=nncf_model_const]; +"63 layer1.1.bn3.bias" [id=63, type=nncf_model_const]; +"64 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" [id=64, type=batch_norm]; +"65 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0" [id=65, type=__iadd__]; +"66 ResNet/Sequential[layer1]/Bottleneck[1]/relu_2" [id=66, type=relu]; +"67 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=67, type=symmetric_quantize]; +"68 layer1.2.conv1.weight" [id=68, type=nncf_model_const]; +"69 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; +"70 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=70, type=conv2d]; +"71 layer1.2.bn1.weight" [id=71, type=nncf_model_const]; +"72 layer1.2.bn1.bias" [id=72, type=nncf_model_const]; +"73 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=73, type=batch_norm]; +"74 ResNet/Sequential[layer1]/Bottleneck[2]/relu_0" [id=74, type=relu]; +"75 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=75, type=symmetric_quantize]; +"76 layer1.2.conv2.weight" [id=76, type=nncf_model_const]; +"77 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=77, type=symmetric_quantize]; +"78 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=78, type=conv2d]; +"79 layer1.2.bn2.weight" [id=79, type=nncf_model_const]; +"80 layer1.2.bn2.bias" [id=80, type=nncf_model_const]; +"81 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=81, type=batch_norm]; +"82 ResNet/Sequential[layer1]/Bottleneck[2]/relu_1" [id=82, type=relu]; +"83 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=83, type=symmetric_quantize]; +"84 layer1.2.conv3.weight" [id=84, type=nncf_model_const]; +"85 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; +"86 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" [id=86, type=conv2d]; +"87 layer1.2.bn3.weight" [id=87, type=nncf_model_const]; +"88 layer1.2.bn3.bias" [id=88, type=nncf_model_const]; +"89 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" [id=89, type=batch_norm]; +"90 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0" [id=90, type=__iadd__]; +"91 ResNet/Sequential[layer1]/Bottleneck[2]/relu_2" [id=91, type=relu]; +"92 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=92, type=symmetric_quantize]; +"93 layer2.0.conv1.weight" [id=93, type=nncf_model_const]; +"94 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=95, type=conv2d]; +"96 layer2.0.bn1.weight" [id=96, type=nncf_model_const]; +"97 layer2.0.bn1.bias" [id=97, type=nncf_model_const]; +"98 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=98, type=batch_norm]; +"99 ResNet/Sequential[layer2]/Bottleneck[0]/relu_0" [id=99, type=relu]; +"100 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; +"101 layer2.0.conv2.weight" [id=101, type=nncf_model_const]; +"102 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=103, type=conv2d]; +"104 layer2.0.bn2.weight" [id=104, type=nncf_model_const]; +"105 layer2.0.bn2.bias" [id=105, type=nncf_model_const]; +"106 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=106, type=batch_norm]; +"107 ResNet/Sequential[layer2]/Bottleneck[0]/relu_1" [id=107, type=relu]; +"108 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=108, type=symmetric_quantize]; +"109 layer2.0.conv3.weight" [id=109, type=nncf_model_const]; +"110 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" [id=111, type=conv2d]; +"112 layer2.0.bn3.weight" [id=112, type=nncf_model_const]; +"113 layer2.0.bn3.bias" [id=113, type=nncf_model_const]; +"114 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" [id=114, type=batch_norm]; +"115 layer2.0.shortcut.0.weight" [id=115, type=nncf_model_const]; +"116 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=117, type=conv2d]; +"118 layer2.0.shortcut.1.weight" [id=118, type=nncf_model_const]; +"119 layer2.0.shortcut.1.bias" [id=119, type=nncf_model_const]; +"120 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=120, type=batch_norm]; +"121 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=121, type=symmetric_quantize]; +"122 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0" [id=122, type=__iadd__]; +"123 ResNet/Sequential[layer2]/Bottleneck[0]/relu_2" [id=123, type=relu]; +"124 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=124, type=symmetric_quantize]; +"125 layer2.1.conv1.weight" [id=125, type=nncf_model_const]; +"126 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; +"127 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=127, type=conv2d]; +"128 layer2.1.bn1.weight" [id=128, type=nncf_model_const]; +"129 layer2.1.bn1.bias" [id=129, type=nncf_model_const]; +"130 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=130, type=batch_norm]; +"131 ResNet/Sequential[layer2]/Bottleneck[1]/relu_0" [id=131, type=relu]; +"132 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=132, type=symmetric_quantize]; +"133 layer2.1.conv2.weight" [id=133, type=nncf_model_const]; +"134 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=134, type=symmetric_quantize]; +"135 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=135, type=conv2d]; +"136 layer2.1.bn2.weight" [id=136, type=nncf_model_const]; +"137 layer2.1.bn2.bias" [id=137, type=nncf_model_const]; +"138 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=138, type=batch_norm]; +"139 ResNet/Sequential[layer2]/Bottleneck[1]/relu_1" [id=139, type=relu]; +"140 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=140, type=symmetric_quantize]; +"141 layer2.1.conv3.weight" [id=141, type=nncf_model_const]; +"142 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; +"143 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" [id=143, type=conv2d]; +"144 layer2.1.bn3.weight" [id=144, type=nncf_model_const]; +"145 layer2.1.bn3.bias" [id=145, type=nncf_model_const]; +"146 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" [id=146, type=batch_norm]; +"147 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0" [id=147, type=__iadd__]; +"148 ResNet/Sequential[layer2]/Bottleneck[1]/relu_2" [id=148, type=relu]; +"149 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=149, type=symmetric_quantize]; +"150 layer2.2.conv1.weight" [id=150, type=nncf_model_const]; +"151 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=151, type=symmetric_quantize]; +"152 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=152, type=conv2d]; +"153 layer2.2.bn1.weight" [id=153, type=nncf_model_const]; +"154 layer2.2.bn1.bias" [id=154, type=nncf_model_const]; +"155 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=155, type=batch_norm]; +"156 ResNet/Sequential[layer2]/Bottleneck[2]/relu_0" [id=156, type=relu]; +"157 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=157, type=symmetric_quantize]; +"158 layer2.2.conv2.weight" [id=158, type=nncf_model_const]; +"159 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=159, type=symmetric_quantize]; +"160 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=160, type=conv2d]; +"161 layer2.2.bn2.weight" [id=161, type=nncf_model_const]; +"162 layer2.2.bn2.bias" [id=162, type=nncf_model_const]; +"163 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=163, type=batch_norm]; +"164 ResNet/Sequential[layer2]/Bottleneck[2]/relu_1" [id=164, type=relu]; +"165 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=165, type=symmetric_quantize]; +"166 layer2.2.conv3.weight" [id=166, type=nncf_model_const]; +"167 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; +"168 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" [id=168, type=conv2d]; +"169 layer2.2.bn3.weight" [id=169, type=nncf_model_const]; +"170 layer2.2.bn3.bias" [id=170, type=nncf_model_const]; +"171 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" [id=171, type=batch_norm]; +"172 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0" [id=172, type=__iadd__]; +"173 ResNet/Sequential[layer2]/Bottleneck[2]/relu_2" [id=173, type=relu]; +"174 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=174, type=symmetric_quantize]; +"175 layer2.3.conv1.weight" [id=175, type=nncf_model_const]; +"176 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=176, type=symmetric_quantize]; +"177 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" [id=177, type=conv2d]; +"178 layer2.3.bn1.weight" [id=178, type=nncf_model_const]; +"179 layer2.3.bn1.bias" [id=179, type=nncf_model_const]; +"180 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" [id=180, type=batch_norm]; +"181 ResNet/Sequential[layer2]/Bottleneck[3]/relu_0" [id=181, type=relu]; +"182 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 layer2.3.conv2.weight" [id=183, type=nncf_model_const]; +"184 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=184, type=symmetric_quantize]; +"185 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" [id=185, type=conv2d]; +"186 layer2.3.bn2.weight" [id=186, type=nncf_model_const]; +"187 layer2.3.bn2.bias" [id=187, type=nncf_model_const]; +"188 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" [id=188, type=batch_norm]; +"189 ResNet/Sequential[layer2]/Bottleneck[3]/relu_1" [id=189, type=relu]; +"190 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=190, type=symmetric_quantize]; +"191 layer2.3.conv3.weight" [id=191, type=nncf_model_const]; +"192 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=192, type=symmetric_quantize]; +"193 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/conv2d_0" [id=193, type=conv2d]; +"194 layer2.3.bn3.weight" [id=194, type=nncf_model_const]; +"195 layer2.3.bn3.bias" [id=195, type=nncf_model_const]; +"196 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0" [id=196, type=batch_norm]; +"197 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0" [id=197, type=__iadd__]; +"198 ResNet/Sequential[layer2]/Bottleneck[3]/relu_2" [id=198, type=relu]; +"199 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" [id=199, type=symmetric_quantize]; +"200 layer3.0.conv1.weight" [id=200, type=nncf_model_const]; +"201 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=201, type=symmetric_quantize]; +"202 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=202, type=conv2d]; +"203 layer3.0.bn1.weight" [id=203, type=nncf_model_const]; +"204 layer3.0.bn1.bias" [id=204, type=nncf_model_const]; +"205 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=205, type=batch_norm]; +"206 ResNet/Sequential[layer3]/Bottleneck[0]/relu_0" [id=206, type=relu]; +"207 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; +"208 layer3.0.conv2.weight" [id=208, type=nncf_model_const]; +"209 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=209, type=symmetric_quantize]; +"210 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=210, type=conv2d]; +"211 layer3.0.bn2.weight" [id=211, type=nncf_model_const]; +"212 layer3.0.bn2.bias" [id=212, type=nncf_model_const]; +"213 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=213, type=batch_norm]; +"214 ResNet/Sequential[layer3]/Bottleneck[0]/relu_1" [id=214, type=relu]; +"215 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=215, type=symmetric_quantize]; +"216 layer3.0.conv3.weight" [id=216, type=nncf_model_const]; +"217 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=217, type=symmetric_quantize]; +"218 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" [id=218, type=conv2d]; +"219 layer3.0.bn3.weight" [id=219, type=nncf_model_const]; +"220 layer3.0.bn3.bias" [id=220, type=nncf_model_const]; +"221 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" [id=221, type=batch_norm]; +"222 layer3.0.shortcut.0.weight" [id=222, type=nncf_model_const]; +"223 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; +"224 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=224, type=conv2d]; +"225 layer3.0.shortcut.1.weight" [id=225, type=nncf_model_const]; +"226 layer3.0.shortcut.1.bias" [id=226, type=nncf_model_const]; +"227 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=227, type=batch_norm]; +"228 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0" [id=229, type=__iadd__]; +"230 ResNet/Sequential[layer3]/Bottleneck[0]/relu_2" [id=230, type=relu]; +"231 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=231, type=symmetric_quantize]; +"232 layer3.1.conv1.weight" [id=232, type=nncf_model_const]; +"233 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=233, type=symmetric_quantize]; +"234 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=234, type=conv2d]; +"235 layer3.1.bn1.weight" [id=235, type=nncf_model_const]; +"236 layer3.1.bn1.bias" [id=236, type=nncf_model_const]; +"237 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=237, type=batch_norm]; +"238 ResNet/Sequential[layer3]/Bottleneck[1]/relu_0" [id=238, type=relu]; +"239 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=239, type=symmetric_quantize]; +"240 layer3.1.conv2.weight" [id=240, type=nncf_model_const]; +"241 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=242, type=conv2d]; +"243 layer3.1.bn2.weight" [id=243, type=nncf_model_const]; +"244 layer3.1.bn2.bias" [id=244, type=nncf_model_const]; +"245 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=245, type=batch_norm]; +"246 ResNet/Sequential[layer3]/Bottleneck[1]/relu_1" [id=246, type=relu]; +"247 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=247, type=symmetric_quantize]; +"248 layer3.1.conv3.weight" [id=248, type=nncf_model_const]; +"249 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=249, type=symmetric_quantize]; +"250 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" [id=250, type=conv2d]; +"251 layer3.1.bn3.weight" [id=251, type=nncf_model_const]; +"252 layer3.1.bn3.bias" [id=252, type=nncf_model_const]; +"253 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" [id=253, type=batch_norm]; +"254 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0" [id=254, type=__iadd__]; +"255 ResNet/Sequential[layer3]/Bottleneck[1]/relu_2" [id=255, type=relu]; +"256 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=256, type=symmetric_quantize]; +"257 layer3.2.conv1.weight" [id=257, type=nncf_model_const]; +"258 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=258, type=symmetric_quantize]; +"259 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=259, type=conv2d]; +"260 layer3.2.bn1.weight" [id=260, type=nncf_model_const]; +"261 layer3.2.bn1.bias" [id=261, type=nncf_model_const]; +"262 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=262, type=batch_norm]; +"263 ResNet/Sequential[layer3]/Bottleneck[2]/relu_0" [id=263, type=relu]; +"264 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=264, type=symmetric_quantize]; +"265 layer3.2.conv2.weight" [id=265, type=nncf_model_const]; +"266 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=266, type=symmetric_quantize]; +"267 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=267, type=conv2d]; +"268 layer3.2.bn2.weight" [id=268, type=nncf_model_const]; +"269 layer3.2.bn2.bias" [id=269, type=nncf_model_const]; +"270 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=270, type=batch_norm]; +"271 ResNet/Sequential[layer3]/Bottleneck[2]/relu_1" [id=271, type=relu]; +"272 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=272, type=symmetric_quantize]; +"273 layer3.2.conv3.weight" [id=273, type=nncf_model_const]; +"274 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=274, type=symmetric_quantize]; +"275 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" [id=275, type=conv2d]; +"276 layer3.2.bn3.weight" [id=276, type=nncf_model_const]; +"277 layer3.2.bn3.bias" [id=277, type=nncf_model_const]; +"278 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" [id=278, type=batch_norm]; +"279 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0" [id=279, type=__iadd__]; +"280 ResNet/Sequential[layer3]/Bottleneck[2]/relu_2" [id=280, type=relu]; +"281 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=281, type=symmetric_quantize]; +"282 layer3.3.conv1.weight" [id=282, type=nncf_model_const]; +"283 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" [id=284, type=conv2d]; +"285 layer3.3.bn1.weight" [id=285, type=nncf_model_const]; +"286 layer3.3.bn1.bias" [id=286, type=nncf_model_const]; +"287 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" [id=287, type=batch_norm]; +"288 ResNet/Sequential[layer3]/Bottleneck[3]/relu_0" [id=288, type=relu]; +"289 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 layer3.3.conv2.weight" [id=290, type=nncf_model_const]; +"291 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" [id=292, type=conv2d]; +"293 layer3.3.bn2.weight" [id=293, type=nncf_model_const]; +"294 layer3.3.bn2.bias" [id=294, type=nncf_model_const]; +"295 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" [id=295, type=batch_norm]; +"296 ResNet/Sequential[layer3]/Bottleneck[3]/relu_1" [id=296, type=relu]; +"297 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" [id=297, type=symmetric_quantize]; +"298 layer3.3.conv3.weight" [id=298, type=nncf_model_const]; +"299 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=299, type=symmetric_quantize]; +"300 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/conv2d_0" [id=300, type=conv2d]; +"301 layer3.3.bn3.weight" [id=301, type=nncf_model_const]; +"302 layer3.3.bn3.bias" [id=302, type=nncf_model_const]; +"303 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0" [id=303, type=batch_norm]; +"304 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0" [id=304, type=__iadd__]; +"305 ResNet/Sequential[layer3]/Bottleneck[3]/relu_2" [id=305, type=relu]; +"306 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" [id=306, type=symmetric_quantize]; +"307 layer3.4.conv1.weight" [id=307, type=nncf_model_const]; +"308 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=308, type=symmetric_quantize]; +"309 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" [id=309, type=conv2d]; +"310 layer3.4.bn1.weight" [id=310, type=nncf_model_const]; +"311 layer3.4.bn1.bias" [id=311, type=nncf_model_const]; +"312 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" [id=312, type=batch_norm]; +"313 ResNet/Sequential[layer3]/Bottleneck[4]/relu_0" [id=313, type=relu]; +"314 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" [id=314, type=symmetric_quantize]; +"315 layer3.4.conv2.weight" [id=315, type=nncf_model_const]; +"316 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=316, type=symmetric_quantize]; +"317 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" [id=317, type=conv2d]; +"318 layer3.4.bn2.weight" [id=318, type=nncf_model_const]; +"319 layer3.4.bn2.bias" [id=319, type=nncf_model_const]; +"320 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" [id=320, type=batch_norm]; +"321 ResNet/Sequential[layer3]/Bottleneck[4]/relu_1" [id=321, type=relu]; +"322 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" [id=322, type=symmetric_quantize]; +"323 layer3.4.conv3.weight" [id=323, type=nncf_model_const]; +"324 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=324, type=symmetric_quantize]; +"325 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/conv2d_0" [id=325, type=conv2d]; +"326 layer3.4.bn3.weight" [id=326, type=nncf_model_const]; +"327 layer3.4.bn3.bias" [id=327, type=nncf_model_const]; +"328 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm_0" [id=328, type=batch_norm]; +"329 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0" [id=329, type=__iadd__]; +"330 ResNet/Sequential[layer3]/Bottleneck[4]/relu_2" [id=330, type=relu]; +"331 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2" [id=331, type=symmetric_quantize]; +"332 layer3.5.conv1.weight" [id=332, type=nncf_model_const]; +"333 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=333, type=symmetric_quantize]; +"334 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" [id=334, type=conv2d]; +"335 layer3.5.bn1.weight" [id=335, type=nncf_model_const]; +"336 layer3.5.bn1.bias" [id=336, type=nncf_model_const]; +"337 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" [id=337, type=batch_norm]; +"338 ResNet/Sequential[layer3]/Bottleneck[5]/relu_0" [id=338, type=relu]; +"339 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 layer3.5.conv2.weight" [id=340, type=nncf_model_const]; +"341 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=341, type=symmetric_quantize]; +"342 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" [id=342, type=conv2d]; +"343 layer3.5.bn2.weight" [id=343, type=nncf_model_const]; +"344 layer3.5.bn2.bias" [id=344, type=nncf_model_const]; +"345 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" [id=345, type=batch_norm]; +"346 ResNet/Sequential[layer3]/Bottleneck[5]/relu_1" [id=346, type=relu]; +"347 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" [id=347, type=symmetric_quantize]; +"348 layer3.5.conv3.weight" [id=348, type=nncf_model_const]; +"349 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=349, type=symmetric_quantize]; +"350 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/conv2d_0" [id=350, type=conv2d]; +"351 layer3.5.bn3.weight" [id=351, type=nncf_model_const]; +"352 layer3.5.bn3.bias" [id=352, type=nncf_model_const]; +"353 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm_0" [id=353, type=batch_norm]; +"354 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0" [id=354, type=__iadd__]; +"355 ResNet/Sequential[layer3]/Bottleneck[5]/relu_2" [id=355, type=relu]; +"356 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2" [id=356, type=symmetric_quantize]; +"357 layer4.0.conv1.weight" [id=357, type=nncf_model_const]; +"358 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=358, type=symmetric_quantize]; +"359 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" [id=359, type=conv2d]; +"360 layer4.0.bn1.weight" [id=360, type=nncf_model_const]; +"361 layer4.0.bn1.bias" [id=361, type=nncf_model_const]; +"362 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" [id=362, type=batch_norm]; +"363 ResNet/Sequential[layer4]/Bottleneck[0]/relu_0" [id=363, type=relu]; +"364 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" [id=364, type=symmetric_quantize]; +"365 layer4.0.conv2.weight" [id=365, type=nncf_model_const]; +"366 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=366, type=symmetric_quantize]; +"367 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" [id=367, type=conv2d]; +"368 layer4.0.bn2.weight" [id=368, type=nncf_model_const]; +"369 layer4.0.bn2.bias" [id=369, type=nncf_model_const]; +"370 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" [id=370, type=batch_norm]; +"371 ResNet/Sequential[layer4]/Bottleneck[0]/relu_1" [id=371, type=relu]; +"372 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" [id=372, type=symmetric_quantize]; +"373 layer4.0.conv3.weight" [id=373, type=nncf_model_const]; +"374 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=374, type=symmetric_quantize]; +"375 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" [id=375, type=conv2d]; +"376 layer4.0.bn3.weight" [id=376, type=nncf_model_const]; +"377 layer4.0.bn3.bias" [id=377, type=nncf_model_const]; +"378 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" [id=378, type=batch_norm]; +"379 layer4.0.shortcut.0.weight" [id=379, type=nncf_model_const]; +"380 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=380, type=symmetric_quantize]; +"381 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" [id=381, type=conv2d]; +"382 layer4.0.shortcut.1.weight" [id=382, type=nncf_model_const]; +"383 layer4.0.shortcut.1.bias" [id=383, type=nncf_model_const]; +"384 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" [id=384, type=batch_norm]; +"385 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=385, type=symmetric_quantize]; +"386 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0" [id=386, type=__iadd__]; +"387 ResNet/Sequential[layer4]/Bottleneck[0]/relu_2" [id=387, type=relu]; +"388 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" [id=388, type=symmetric_quantize]; +"389 layer4.1.conv1.weight" [id=389, type=nncf_model_const]; +"390 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=390, type=symmetric_quantize]; +"391 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" [id=391, type=conv2d]; +"392 layer4.1.bn1.weight" [id=392, type=nncf_model_const]; +"393 layer4.1.bn1.bias" [id=393, type=nncf_model_const]; +"394 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" [id=394, type=batch_norm]; +"395 ResNet/Sequential[layer4]/Bottleneck[1]/relu_0" [id=395, type=relu]; +"396 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" [id=396, type=symmetric_quantize]; +"397 layer4.1.conv2.weight" [id=397, type=nncf_model_const]; +"398 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=398, type=symmetric_quantize]; +"399 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" [id=399, type=conv2d]; +"400 layer4.1.bn2.weight" [id=400, type=nncf_model_const]; +"401 layer4.1.bn2.bias" [id=401, type=nncf_model_const]; +"402 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" [id=402, type=batch_norm]; +"403 ResNet/Sequential[layer4]/Bottleneck[1]/relu_1" [id=403, type=relu]; +"404 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" [id=404, type=symmetric_quantize]; +"405 layer4.1.conv3.weight" [id=405, type=nncf_model_const]; +"406 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=406, type=symmetric_quantize]; +"407 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" [id=407, type=conv2d]; +"408 layer4.1.bn3.weight" [id=408, type=nncf_model_const]; +"409 layer4.1.bn3.bias" [id=409, type=nncf_model_const]; +"410 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" [id=410, type=batch_norm]; +"411 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0" [id=411, type=__iadd__]; +"412 ResNet/Sequential[layer4]/Bottleneck[1]/relu_2" [id=412, type=relu]; +"413 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" [id=413, type=symmetric_quantize]; +"414 layer4.2.conv1.weight" [id=414, type=nncf_model_const]; +"415 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=415, type=symmetric_quantize]; +"416 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" [id=416, type=conv2d]; +"417 layer4.2.bn1.weight" [id=417, type=nncf_model_const]; +"418 layer4.2.bn1.bias" [id=418, type=nncf_model_const]; +"419 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" [id=419, type=batch_norm]; +"420 ResNet/Sequential[layer4]/Bottleneck[2]/relu_0" [id=420, type=relu]; +"421 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" [id=421, type=symmetric_quantize]; +"422 layer4.2.conv2.weight" [id=422, type=nncf_model_const]; +"423 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=423, type=symmetric_quantize]; +"424 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" [id=424, type=conv2d]; +"425 layer4.2.bn2.weight" [id=425, type=nncf_model_const]; +"426 layer4.2.bn2.bias" [id=426, type=nncf_model_const]; +"427 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" [id=427, type=batch_norm]; +"428 ResNet/Sequential[layer4]/Bottleneck[2]/relu_1" [id=428, type=relu]; +"429 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" [id=429, type=symmetric_quantize]; +"430 layer4.2.conv3.weight" [id=430, type=nncf_model_const]; +"431 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=431, type=symmetric_quantize]; +"432 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" [id=432, type=conv2d]; +"433 layer4.2.bn3.weight" [id=433, type=nncf_model_const]; +"434 layer4.2.bn3.bias" [id=434, type=nncf_model_const]; +"435 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" [id=435, type=batch_norm]; +"436 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0" [id=436, type=__iadd__]; +"437 ResNet/Sequential[layer4]/Bottleneck[2]/relu_2" [id=437, type=relu]; +"438 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" [id=438, type=symmetric_quantize]; +"439 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" [id=439, type=adaptive_avg_pool2d]; +"440 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" [id=440, type=symmetric_quantize]; +"441 ResNet/flatten_0" [id=441, type=flatten]; +"442 linear.weight" [id=442, type=nncf_model_const]; +"443 linear.bias" [id=443, type=nncf_model_const]; +"444 ResNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" [id=444, type=symmetric_quantize]; +"445 ResNet/Linear[linear]/linear_0" [id=445, type=linear]; +"446 /nncf_model_output_0" [id=446, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 ResNet/NNCFConv2d[conv1]/conv2d_0"; -"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 ResNet/NNCFConv2d[conv1]/conv2d_0"; -"3 ResNet/NNCFConv2d[conv1]/conv2d_0" -> "4 ResNet/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"4 ResNet/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "5 ResNet/relu_0"; -"5 ResNet/relu_0" -> "6 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0"; -"6 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d_0"; -"7 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"7 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "10 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"10 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "11 ResNet/Sequential[layer1]/Bottleneck[0]/relu_0"; -"11 ResNet/Sequential[layer1]/Bottleneck[0]/relu_0" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"12 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "15 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"15 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/relu_1"; -"16 ResNet/Sequential[layer1]/Bottleneck[0]/relu_1" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"17 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"20 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0"; -"21 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0"; -"25 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/relu_2"; -"26 ResNet/Sequential[layer1]/Bottleneck[0]/relu_2" -> "27 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; -"27 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"27 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0"; -"28 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "31 ResNet/Sequential[layer1]/Bottleneck[1]/relu_0"; -"31 ResNet/Sequential[layer1]/Bottleneck[1]/relu_0" -> "32 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"32 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"33 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "36 ResNet/Sequential[layer1]/Bottleneck[1]/relu_1"; -"36 ResNet/Sequential[layer1]/Bottleneck[1]/relu_1" -> "37 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"37 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"38 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0"; -"41 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0" -> "42 ResNet/Sequential[layer1]/Bottleneck[1]/relu_2"; -"42 ResNet/Sequential[layer1]/Bottleneck[1]/relu_2" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; -"43 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "45 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"43 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0"; -"44 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "45 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"45 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/relu_0"; -"47 ResNet/Sequential[layer1]/Bottleneck[2]/relu_0" -> "48 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"48 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"49 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"50 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/relu_1"; -"52 ResNet/Sequential[layer1]/Bottleneck[2]/relu_1" -> "53 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"53 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"54 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"55 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0"; -"57 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0" -> "58 ResNet/Sequential[layer1]/Bottleneck[2]/relu_2"; -"58 ResNet/Sequential[layer1]/Bottleneck[2]/relu_2" -> "59 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; -"59 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "61 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"59 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"60 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "61 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"61 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "62 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"62 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "63 ResNet/Sequential[layer2]/Bottleneck[0]/relu_0"; -"63 ResNet/Sequential[layer2]/Bottleneck[0]/relu_0" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"64 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"65 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"66 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "67 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"67 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "68 ResNet/Sequential[layer2]/Bottleneck[0]/relu_1"; -"68 ResNet/Sequential[layer2]/Bottleneck[0]/relu_1" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"69 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"70 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"71 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "72 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"72 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "77 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0"; -"73 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"74 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "75 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"75 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "76 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"76 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "77 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0"; -"77 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/relu_2"; -"78 ResNet/Sequential[layer2]/Bottleneck[0]/relu_2" -> "79 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; -"79 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "81 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"79 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0"; -"80 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "81 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"81 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "82 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"82 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "83 ResNet/Sequential[layer2]/Bottleneck[1]/relu_0"; -"83 ResNet/Sequential[layer2]/Bottleneck[1]/relu_0" -> "84 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"84 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"86 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "87 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"87 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "88 ResNet/Sequential[layer2]/Bottleneck[1]/relu_1"; -"88 ResNet/Sequential[layer2]/Bottleneck[1]/relu_1" -> "89 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"89 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"91 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "92 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"92 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0"; -"93 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0" -> "94 ResNet/Sequential[layer2]/Bottleneck[1]/relu_2"; -"94 ResNet/Sequential[layer2]/Bottleneck[1]/relu_2" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; -"95 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "97 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"95 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0"; -"96 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "97 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"97 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "98 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"98 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "99 ResNet/Sequential[layer2]/Bottleneck[2]/relu_0"; -"99 ResNet/Sequential[layer2]/Bottleneck[2]/relu_0" -> "100 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"100 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "103 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"103 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "104 ResNet/Sequential[layer2]/Bottleneck[2]/relu_1"; -"104 ResNet/Sequential[layer2]/Bottleneck[2]/relu_1" -> "105 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"105 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "108 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"108 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0"; -"109 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0" -> "110 ResNet/Sequential[layer2]/Bottleneck[2]/relu_2"; -"110 ResNet/Sequential[layer2]/Bottleneck[2]/relu_2" -> "111 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; -"111 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "113 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"111 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0"; -"112 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "113 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"113 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "114 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"114 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "115 ResNet/Sequential[layer2]/Bottleneck[3]/relu_0"; -"115 ResNet/Sequential[layer2]/Bottleneck[3]/relu_0" -> "116 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; -"116 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"117 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "120 ResNet/Sequential[layer2]/Bottleneck[3]/relu_1"; -"120 ResNet/Sequential[layer2]/Bottleneck[3]/relu_1" -> "121 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; -"121 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; -"122 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; -"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0"; -"125 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0" -> "126 ResNet/Sequential[layer2]/Bottleneck[3]/relu_2"; -"126 ResNet/Sequential[layer2]/Bottleneck[3]/relu_2" -> "127 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2"; -"127 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "129 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"127 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"128 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "129 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"129 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "130 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"130 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "131 ResNet/Sequential[layer3]/Bottleneck[0]/relu_0"; -"131 ResNet/Sequential[layer3]/Bottleneck[0]/relu_0" -> "132 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"132 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "134 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"133 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "134 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"134 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/relu_1"; -"136 ResNet/Sequential[layer3]/Bottleneck[0]/relu_1" -> "137 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"137 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"138 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"139 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "145 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0"; -"141 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"142 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "143 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"143 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "144 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"144 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "145 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0"; -"145 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/relu_2"; -"146 ResNet/Sequential[layer3]/Bottleneck[0]/relu_2" -> "147 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; -"147 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "149 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"147 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "161 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0"; -"148 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"149 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "150 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"150 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "151 ResNet/Sequential[layer3]/Bottleneck[1]/relu_0"; -"151 ResNet/Sequential[layer3]/Bottleneck[1]/relu_0" -> "152 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"152 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "154 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"153 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "154 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"154 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "155 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"155 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "156 ResNet/Sequential[layer3]/Bottleneck[1]/relu_1"; -"156 ResNet/Sequential[layer3]/Bottleneck[1]/relu_1" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"157 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"158 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"159 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "160 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"160 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "161 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0"; -"161 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/relu_2"; -"162 ResNet/Sequential[layer3]/Bottleneck[1]/relu_2" -> "163 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; -"163 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "165 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"163 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0"; -"164 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "165 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"165 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "166 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"166 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "167 ResNet/Sequential[layer3]/Bottleneck[2]/relu_0"; -"167 ResNet/Sequential[layer3]/Bottleneck[2]/relu_0" -> "168 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"168 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "170 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"169 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "170 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"170 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "171 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"171 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "172 ResNet/Sequential[layer3]/Bottleneck[2]/relu_1"; -"172 ResNet/Sequential[layer3]/Bottleneck[2]/relu_1" -> "173 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"173 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"175 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "176 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"176 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0"; -"177 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0" -> "178 ResNet/Sequential[layer3]/Bottleneck[2]/relu_2"; -"178 ResNet/Sequential[layer3]/Bottleneck[2]/relu_2" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; -"179 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "181 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"179 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0"; -"180 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "181 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; -"181 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "182 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"182 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "183 ResNet/Sequential[layer3]/Bottleneck[3]/relu_0"; -"183 ResNet/Sequential[layer3]/Bottleneck[3]/relu_0" -> "184 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; -"184 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "186 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"185 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "186 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; -"186 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "187 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"187 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "188 ResNet/Sequential[layer3]/Bottleneck[3]/relu_1"; -"188 ResNet/Sequential[layer3]/Bottleneck[3]/relu_1" -> "189 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; -"189 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; -"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; -"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" -> "192 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"192 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0"; -"193 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0" -> "194 ResNet/Sequential[layer3]/Bottleneck[3]/relu_2"; -"194 ResNet/Sequential[layer3]/Bottleneck[3]/relu_2" -> "195 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2"; -"195 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "197 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"195 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0"; -"196 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "197 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; -"197 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "198 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"198 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "199 ResNet/Sequential[layer3]/Bottleneck[4]/relu_0"; -"199 ResNet/Sequential[layer3]/Bottleneck[4]/relu_0" -> "200 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; -"200 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "202 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"201 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "202 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; -"202 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "203 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"203 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "204 ResNet/Sequential[layer3]/Bottleneck[4]/relu_1"; -"204 ResNet/Sequential[layer3]/Bottleneck[4]/relu_1" -> "205 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; -"205 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0"; -"206 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0"; -"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0"; -"209 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0" -> "210 ResNet/Sequential[layer3]/Bottleneck[4]/relu_2"; -"210 ResNet/Sequential[layer3]/Bottleneck[4]/relu_2" -> "211 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2"; -"211 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2" -> "213 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"211 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0"; -"212 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "213 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; -"213 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "214 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"214 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "215 ResNet/Sequential[layer3]/Bottleneck[5]/relu_0"; -"215 ResNet/Sequential[layer3]/Bottleneck[5]/relu_0" -> "216 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; -"216 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "218 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"217 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "218 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; -"218 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "219 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"219 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "220 ResNet/Sequential[layer3]/Bottleneck[5]/relu_1"; -"220 ResNet/Sequential[layer3]/Bottleneck[5]/relu_1" -> "221 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; -"221 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "223 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0"; -"222 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "223 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0"; -"223 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0" -> "224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0"; -"225 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0" -> "226 ResNet/Sequential[layer3]/Bottleneck[5]/relu_2"; -"226 ResNet/Sequential[layer3]/Bottleneck[5]/relu_2" -> "227 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2"; -"227 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2" -> "229 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"227 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"228 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "229 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; -"229 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "230 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"230 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "231 ResNet/Sequential[layer4]/Bottleneck[0]/relu_0"; -"231 ResNet/Sequential[layer4]/Bottleneck[0]/relu_0" -> "232 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; -"232 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "234 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"233 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "234 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; -"234 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "235 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"235 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "236 ResNet/Sequential[layer4]/Bottleneck[0]/relu_1"; -"236 ResNet/Sequential[layer4]/Bottleneck[0]/relu_1" -> "237 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; -"237 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "239 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"238 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "239 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; -"239 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "240 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"240 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0"; -"241 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0"; -"242 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFConv2d[0]/conv2d_0" -> "243 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0"; -"243 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/batch_norm_0" -> "244 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; -"244 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0"; -"245 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0" -> "246 ResNet/Sequential[layer4]/Bottleneck[0]/relu_2"; -"246 ResNet/Sequential[layer4]/Bottleneck[0]/relu_2" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; -"247 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "249 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"247 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "261 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0"; -"248 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "249 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; -"249 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "250 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"250 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "251 ResNet/Sequential[layer4]/Bottleneck[1]/relu_0"; -"251 ResNet/Sequential[layer4]/Bottleneck[1]/relu_0" -> "252 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; -"252 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "254 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"253 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "254 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; -"254 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "255 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"255 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "256 ResNet/Sequential[layer4]/Bottleneck[1]/relu_1"; -"256 ResNet/Sequential[layer4]/Bottleneck[1]/relu_1" -> "257 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; -"257 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "259 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"258 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "259 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; -"259 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "260 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"260 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "261 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0"; -"261 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0" -> "262 ResNet/Sequential[layer4]/Bottleneck[1]/relu_2"; -"262 ResNet/Sequential[layer4]/Bottleneck[1]/relu_2" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; -"263 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "265 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"263 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "277 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0"; -"264 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "265 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; -"265 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "266 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"266 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "267 ResNet/Sequential[layer4]/Bottleneck[2]/relu_0"; -"267 ResNet/Sequential[layer4]/Bottleneck[2]/relu_0" -> "268 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; -"268 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "270 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"269 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "270 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; -"270 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "271 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"271 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "272 ResNet/Sequential[layer4]/Bottleneck[2]/relu_1"; -"272 ResNet/Sequential[layer4]/Bottleneck[2]/relu_1" -> "273 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; -"273 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "275 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"274 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "275 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; -"275 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "276 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"276 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "277 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0"; -"277 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0" -> "278 ResNet/Sequential[layer4]/Bottleneck[2]/relu_2"; -"278 ResNet/Sequential[layer4]/Bottleneck[2]/relu_2" -> "279 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; -"279 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "280 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0"; -"280 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" -> "281 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; -"281 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "282 ResNet/flatten_0"; -"282 ResNet/flatten_0" -> "284 ResNet/NNCFLinear[linear]/linear_0"; -"283 ResNet/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "284 ResNet/NNCFLinear[linear]/linear_0"; -"284 ResNet/NNCFLinear[linear]/linear_0" -> "285 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "4 ResNet/Conv2d[conv1]/conv2d_0"; +"2 conv1.weight" -> "3 ResNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"3 ResNet/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "4 ResNet/Conv2d[conv1]/conv2d_0"; +"4 ResNet/Conv2d[conv1]/conv2d_0" -> "7 ResNet/BatchNorm2d[bn1]/batch_norm_0"; +"5 bn1.weight" -> "7 ResNet/BatchNorm2d[bn1]/batch_norm_0"; +"6 bn1.bias" -> "7 ResNet/BatchNorm2d[bn1]/batch_norm_0"; +"7 ResNet/BatchNorm2d[bn1]/batch_norm_0" -> "8 ResNet/relu_0"; +"8 ResNet/relu_0" -> "9 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0"; +"9 ResNet/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ResNet/relu_0|OUTPUT]/symmetric_quantize_0" -> "10 ResNet/MaxPool2d[maxpool]/max_pool2d_0"; +"10 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "13 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"10 ResNet/MaxPool2d[maxpool]/max_pool2d_0" -> "35 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"11 layer1.0.conv1.weight" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "13 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"14 layer1.0.bn1.weight" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"15 layer1.0.bn1.bias" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/relu_0"; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/relu_0" -> "18 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"19 layer1.0.conv2.weight" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"22 layer1.0.bn2.weight" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"23 layer1.0.bn2.bias" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/relu_1"; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/relu_1" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "29 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"27 layer1.0.conv3.weight" -> "28 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "29 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"29 ResNet/Sequential[layer1]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" -> "32 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"30 layer1.0.bn3.weight" -> "32 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"31 layer1.0.bn3.bias" -> "32 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"32 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" -> "40 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0"; +"33 layer1.0.shortcut.0.weight" -> "34 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"34 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "35 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"35 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "38 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"36 layer1.0.shortcut.1.weight" -> "38 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"37 layer1.0.shortcut.1.bias" -> "38 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"38 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "39 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"39 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "40 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0"; +"40 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd___0" -> "41 ResNet/Sequential[layer1]/Bottleneck[0]/relu_2"; +"41 ResNet/Sequential[layer1]/Bottleneck[0]/relu_2" -> "42 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; +"42 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"42 ResNet/Sequential[layer1]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "65 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0"; +"43 layer1.1.conv1.weight" -> "44 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "48 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"46 layer1.1.bn1.weight" -> "48 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"47 layer1.1.bn1.bias" -> "48 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"48 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "49 ResNet/Sequential[layer1]/Bottleneck[1]/relu_0"; +"49 ResNet/Sequential[layer1]/Bottleneck[1]/relu_0" -> "50 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"50 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "53 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"51 layer1.1.conv2.weight" -> "52 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"52 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "53 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"53 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "56 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"54 layer1.1.bn2.weight" -> "56 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"55 layer1.1.bn2.bias" -> "56 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"56 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "57 ResNet/Sequential[layer1]/Bottleneck[1]/relu_1"; +"57 ResNet/Sequential[layer1]/Bottleneck[1]/relu_1" -> "58 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"58 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "61 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"59 layer1.1.conv3.weight" -> "60 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"60 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "61 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"61 ResNet/Sequential[layer1]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" -> "64 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"62 layer1.1.bn3.weight" -> "64 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"63 layer1.1.bn3.bias" -> "64 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"64 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" -> "65 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0"; +"65 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd___0" -> "66 ResNet/Sequential[layer1]/Bottleneck[1]/relu_2"; +"66 ResNet/Sequential[layer1]/Bottleneck[1]/relu_2" -> "67 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; +"67 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "70 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"67 ResNet/Sequential[layer1]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "90 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0"; +"68 layer1.2.conv1.weight" -> "69 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"69 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "70 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"70 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "73 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"71 layer1.2.bn1.weight" -> "73 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"72 layer1.2.bn1.bias" -> "73 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"73 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "74 ResNet/Sequential[layer1]/Bottleneck[2]/relu_0"; +"74 ResNet/Sequential[layer1]/Bottleneck[2]/relu_0" -> "75 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"75 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "78 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"76 layer1.2.conv2.weight" -> "77 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"77 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "78 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"78 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "81 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"79 layer1.2.bn2.weight" -> "81 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"80 layer1.2.bn2.bias" -> "81 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"81 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "82 ResNet/Sequential[layer1]/Bottleneck[2]/relu_1"; +"82 ResNet/Sequential[layer1]/Bottleneck[2]/relu_1" -> "83 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"83 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "86 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"84 layer1.2.conv3.weight" -> "85 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"85 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "86 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"86 ResNet/Sequential[layer1]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" -> "89 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"87 layer1.2.bn3.weight" -> "89 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"88 layer1.2.bn3.bias" -> "89 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"89 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" -> "90 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0"; +"90 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd___0" -> "91 ResNet/Sequential[layer1]/Bottleneck[2]/relu_2"; +"91 ResNet/Sequential[layer1]/Bottleneck[2]/relu_2" -> "92 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; +"92 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "95 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"92 ResNet/Sequential[layer1]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "117 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"93 layer2.0.conv1.weight" -> "94 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"94 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "95 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"95 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "98 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"96 layer2.0.bn1.weight" -> "98 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"97 layer2.0.bn1.bias" -> "98 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"98 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "99 ResNet/Sequential[layer2]/Bottleneck[0]/relu_0"; +"99 ResNet/Sequential[layer2]/Bottleneck[0]/relu_0" -> "100 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"100 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "103 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"101 layer2.0.conv2.weight" -> "102 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"102 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "103 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"103 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "106 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"104 layer2.0.bn2.weight" -> "106 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"105 layer2.0.bn2.bias" -> "106 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"106 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "107 ResNet/Sequential[layer2]/Bottleneck[0]/relu_1"; +"107 ResNet/Sequential[layer2]/Bottleneck[0]/relu_1" -> "108 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"108 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "111 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"109 layer2.0.conv3.weight" -> "110 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"110 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "111 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"111 ResNet/Sequential[layer2]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" -> "114 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"112 layer2.0.bn3.weight" -> "114 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"113 layer2.0.bn3.bias" -> "114 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"114 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" -> "122 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0"; +"115 layer2.0.shortcut.0.weight" -> "116 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"116 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "117 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"117 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "120 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"118 layer2.0.shortcut.1.weight" -> "120 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"119 layer2.0.shortcut.1.bias" -> "120 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"120 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "121 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"121 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "122 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0"; +"122 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd___0" -> "123 ResNet/Sequential[layer2]/Bottleneck[0]/relu_2"; +"123 ResNet/Sequential[layer2]/Bottleneck[0]/relu_2" -> "124 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; +"124 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "127 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"124 ResNet/Sequential[layer2]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "147 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0"; +"125 layer2.1.conv1.weight" -> "126 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"126 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "127 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"127 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "130 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"128 layer2.1.bn1.weight" -> "130 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"129 layer2.1.bn1.bias" -> "130 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"130 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "131 ResNet/Sequential[layer2]/Bottleneck[1]/relu_0"; +"131 ResNet/Sequential[layer2]/Bottleneck[1]/relu_0" -> "132 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"132 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "135 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"133 layer2.1.conv2.weight" -> "134 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"134 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "135 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"135 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "138 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"136 layer2.1.bn2.weight" -> "138 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"137 layer2.1.bn2.bias" -> "138 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"138 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "139 ResNet/Sequential[layer2]/Bottleneck[1]/relu_1"; +"139 ResNet/Sequential[layer2]/Bottleneck[1]/relu_1" -> "140 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"140 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "143 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"141 layer2.1.conv3.weight" -> "142 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"142 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "143 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"143 ResNet/Sequential[layer2]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" -> "146 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"144 layer2.1.bn3.weight" -> "146 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"145 layer2.1.bn3.bias" -> "146 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"146 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" -> "147 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0"; +"147 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd___0" -> "148 ResNet/Sequential[layer2]/Bottleneck[1]/relu_2"; +"148 ResNet/Sequential[layer2]/Bottleneck[1]/relu_2" -> "149 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; +"149 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "152 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"149 ResNet/Sequential[layer2]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "172 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0"; +"150 layer2.2.conv1.weight" -> "151 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"151 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "152 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"152 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "155 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"153 layer2.2.bn1.weight" -> "155 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"154 layer2.2.bn1.bias" -> "155 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"155 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "156 ResNet/Sequential[layer2]/Bottleneck[2]/relu_0"; +"156 ResNet/Sequential[layer2]/Bottleneck[2]/relu_0" -> "157 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"157 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "160 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"158 layer2.2.conv2.weight" -> "159 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"159 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "160 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"160 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "163 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"161 layer2.2.bn2.weight" -> "163 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"162 layer2.2.bn2.bias" -> "163 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"163 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "164 ResNet/Sequential[layer2]/Bottleneck[2]/relu_1"; +"164 ResNet/Sequential[layer2]/Bottleneck[2]/relu_1" -> "165 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"165 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "168 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"166 layer2.2.conv3.weight" -> "167 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"167 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "168 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"168 ResNet/Sequential[layer2]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" -> "171 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"169 layer2.2.bn3.weight" -> "171 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"170 layer2.2.bn3.bias" -> "171 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"171 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" -> "172 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0"; +"172 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd___0" -> "173 ResNet/Sequential[layer2]/Bottleneck[2]/relu_2"; +"173 ResNet/Sequential[layer2]/Bottleneck[2]/relu_2" -> "174 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; +"174 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "177 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"174 ResNet/Sequential[layer2]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "197 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0"; +"175 layer2.3.conv1.weight" -> "176 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"176 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "177 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"177 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" -> "180 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"178 layer2.3.bn1.weight" -> "180 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"179 layer2.3.bn1.bias" -> "180 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"180 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" -> "181 ResNet/Sequential[layer2]/Bottleneck[3]/relu_0"; +"181 ResNet/Sequential[layer2]/Bottleneck[3]/relu_0" -> "182 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; +"182 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "185 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"183 layer2.3.conv2.weight" -> "184 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"184 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "185 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"185 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" -> "188 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"186 layer2.3.bn2.weight" -> "188 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"187 layer2.3.bn2.bias" -> "188 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"188 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" -> "189 ResNet/Sequential[layer2]/Bottleneck[3]/relu_1"; +"189 ResNet/Sequential[layer2]/Bottleneck[3]/relu_1" -> "190 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; +"190 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "193 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/conv2d_0"; +"191 layer2.3.conv3.weight" -> "192 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"192 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "193 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/conv2d_0"; +"193 ResNet/Sequential[layer2]/Bottleneck[3]/Conv2d[conv3]/conv2d_0" -> "196 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0"; +"194 layer2.3.bn3.weight" -> "196 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0"; +"195 layer2.3.bn3.bias" -> "196 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0"; +"196 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0" -> "197 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0"; +"197 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd___0" -> "198 ResNet/Sequential[layer2]/Bottleneck[3]/relu_2"; +"198 ResNet/Sequential[layer2]/Bottleneck[3]/relu_2" -> "199 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2"; +"199 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "202 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"199 ResNet/Sequential[layer2]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "224 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"200 layer3.0.conv1.weight" -> "201 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"201 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "202 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"202 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "205 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"203 layer3.0.bn1.weight" -> "205 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"204 layer3.0.bn1.bias" -> "205 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"205 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "206 ResNet/Sequential[layer3]/Bottleneck[0]/relu_0"; +"206 ResNet/Sequential[layer3]/Bottleneck[0]/relu_0" -> "207 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"207 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "210 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"208 layer3.0.conv2.weight" -> "209 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"209 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "210 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"210 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "213 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"211 layer3.0.bn2.weight" -> "213 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"212 layer3.0.bn2.bias" -> "213 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"213 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "214 ResNet/Sequential[layer3]/Bottleneck[0]/relu_1"; +"214 ResNet/Sequential[layer3]/Bottleneck[0]/relu_1" -> "215 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"215 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "218 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"216 layer3.0.conv3.weight" -> "217 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"217 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "218 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"218 ResNet/Sequential[layer3]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" -> "221 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"219 layer3.0.bn3.weight" -> "221 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"220 layer3.0.bn3.bias" -> "221 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"221 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" -> "229 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0"; +"222 layer3.0.shortcut.0.weight" -> "223 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"223 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "224 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"224 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "227 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"225 layer3.0.shortcut.1.weight" -> "227 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"226 layer3.0.shortcut.1.bias" -> "227 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"227 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "228 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"228 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "229 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0"; +"229 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd___0" -> "230 ResNet/Sequential[layer3]/Bottleneck[0]/relu_2"; +"230 ResNet/Sequential[layer3]/Bottleneck[0]/relu_2" -> "231 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; +"231 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "234 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"231 ResNet/Sequential[layer3]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "254 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0"; +"232 layer3.1.conv1.weight" -> "233 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"233 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "234 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"234 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "237 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"235 layer3.1.bn1.weight" -> "237 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"236 layer3.1.bn1.bias" -> "237 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"237 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "238 ResNet/Sequential[layer3]/Bottleneck[1]/relu_0"; +"238 ResNet/Sequential[layer3]/Bottleneck[1]/relu_0" -> "239 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"239 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "242 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"240 layer3.1.conv2.weight" -> "241 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"241 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "242 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"242 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "245 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"243 layer3.1.bn2.weight" -> "245 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"244 layer3.1.bn2.bias" -> "245 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"245 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "246 ResNet/Sequential[layer3]/Bottleneck[1]/relu_1"; +"246 ResNet/Sequential[layer3]/Bottleneck[1]/relu_1" -> "247 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"247 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "250 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"248 layer3.1.conv3.weight" -> "249 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"249 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "250 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"250 ResNet/Sequential[layer3]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" -> "253 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"251 layer3.1.bn3.weight" -> "253 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"252 layer3.1.bn3.bias" -> "253 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"253 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" -> "254 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0"; +"254 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd___0" -> "255 ResNet/Sequential[layer3]/Bottleneck[1]/relu_2"; +"255 ResNet/Sequential[layer3]/Bottleneck[1]/relu_2" -> "256 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; +"256 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "259 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"256 ResNet/Sequential[layer3]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "279 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0"; +"257 layer3.2.conv1.weight" -> "258 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"258 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "259 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"259 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "262 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"260 layer3.2.bn1.weight" -> "262 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"261 layer3.2.bn1.bias" -> "262 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"262 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "263 ResNet/Sequential[layer3]/Bottleneck[2]/relu_0"; +"263 ResNet/Sequential[layer3]/Bottleneck[2]/relu_0" -> "264 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"264 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "267 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"265 layer3.2.conv2.weight" -> "266 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"266 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "267 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"267 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "270 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"268 layer3.2.bn2.weight" -> "270 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"269 layer3.2.bn2.bias" -> "270 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"270 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "271 ResNet/Sequential[layer3]/Bottleneck[2]/relu_1"; +"271 ResNet/Sequential[layer3]/Bottleneck[2]/relu_1" -> "272 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"272 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "275 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"273 layer3.2.conv3.weight" -> "274 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"274 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "275 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"275 ResNet/Sequential[layer3]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" -> "278 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"276 layer3.2.bn3.weight" -> "278 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"277 layer3.2.bn3.bias" -> "278 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"278 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" -> "279 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0"; +"279 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd___0" -> "280 ResNet/Sequential[layer3]/Bottleneck[2]/relu_2"; +"280 ResNet/Sequential[layer3]/Bottleneck[2]/relu_2" -> "281 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; +"281 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "284 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"281 ResNet/Sequential[layer3]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "304 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0"; +"282 layer3.3.conv1.weight" -> "283 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"283 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "284 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0"; +"284 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv1]/conv2d_0" -> "287 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"285 layer3.3.bn1.weight" -> "287 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"286 layer3.3.bn1.bias" -> "287 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0"; +"287 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm_0" -> "288 ResNet/Sequential[layer3]/Bottleneck[3]/relu_0"; +"288 ResNet/Sequential[layer3]/Bottleneck[3]/relu_0" -> "289 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0"; +"289 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_0" -> "292 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"290 layer3.3.conv2.weight" -> "291 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"291 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "292 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0"; +"292 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv2]/conv2d_0" -> "295 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"293 layer3.3.bn2.weight" -> "295 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"294 layer3.3.bn2.bias" -> "295 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0"; +"295 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm_0" -> "296 ResNet/Sequential[layer3]/Bottleneck[3]/relu_1"; +"296 ResNet/Sequential[layer3]/Bottleneck[3]/relu_1" -> "297 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1"; +"297 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_1" -> "300 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/conv2d_0"; +"298 layer3.3.conv3.weight" -> "299 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"299 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "300 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/conv2d_0"; +"300 ResNet/Sequential[layer3]/Bottleneck[3]/Conv2d[conv3]/conv2d_0" -> "303 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0"; +"301 layer3.3.bn3.weight" -> "303 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0"; +"302 layer3.3.bn3.bias" -> "303 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0"; +"303 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm_0" -> "304 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0"; +"304 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd___0" -> "305 ResNet/Sequential[layer3]/Bottleneck[3]/relu_2"; +"305 ResNet/Sequential[layer3]/Bottleneck[3]/relu_2" -> "306 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2"; +"306 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "309 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"306 ResNet/Sequential[layer3]/Bottleneck[3]/SymmetricQuantizer/symmetric_quantize_2" -> "329 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0"; +"307 layer3.4.conv1.weight" -> "308 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"308 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "309 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0"; +"309 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv1]/conv2d_0" -> "312 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"310 layer3.4.bn1.weight" -> "312 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"311 layer3.4.bn1.bias" -> "312 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0"; +"312 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm_0" -> "313 ResNet/Sequential[layer3]/Bottleneck[4]/relu_0"; +"313 ResNet/Sequential[layer3]/Bottleneck[4]/relu_0" -> "314 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0"; +"314 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_0" -> "317 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"315 layer3.4.conv2.weight" -> "316 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"316 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "317 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0"; +"317 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv2]/conv2d_0" -> "320 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"318 layer3.4.bn2.weight" -> "320 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"319 layer3.4.bn2.bias" -> "320 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0"; +"320 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm_0" -> "321 ResNet/Sequential[layer3]/Bottleneck[4]/relu_1"; +"321 ResNet/Sequential[layer3]/Bottleneck[4]/relu_1" -> "322 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1"; +"322 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_1" -> "325 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/conv2d_0"; +"323 layer3.4.conv3.weight" -> "324 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"324 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "325 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/conv2d_0"; +"325 ResNet/Sequential[layer3]/Bottleneck[4]/Conv2d[conv3]/conv2d_0" -> "328 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm_0"; +"326 layer3.4.bn3.weight" -> "328 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm_0"; +"327 layer3.4.bn3.bias" -> "328 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm_0"; +"328 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm_0" -> "329 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0"; +"329 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd___0" -> "330 ResNet/Sequential[layer3]/Bottleneck[4]/relu_2"; +"330 ResNet/Sequential[layer3]/Bottleneck[4]/relu_2" -> "331 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2"; +"331 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2" -> "334 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"331 ResNet/Sequential[layer3]/Bottleneck[4]/SymmetricQuantizer/symmetric_quantize_2" -> "354 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0"; +"332 layer3.5.conv1.weight" -> "333 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"333 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "334 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0"; +"334 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv1]/conv2d_0" -> "337 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"335 layer3.5.bn1.weight" -> "337 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"336 layer3.5.bn1.bias" -> "337 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0"; +"337 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm_0" -> "338 ResNet/Sequential[layer3]/Bottleneck[5]/relu_0"; +"338 ResNet/Sequential[layer3]/Bottleneck[5]/relu_0" -> "339 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0"; +"339 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_0" -> "342 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"340 layer3.5.conv2.weight" -> "341 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"341 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "342 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0"; +"342 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv2]/conv2d_0" -> "345 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"343 layer3.5.bn2.weight" -> "345 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"344 layer3.5.bn2.bias" -> "345 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0"; +"345 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm_0" -> "346 ResNet/Sequential[layer3]/Bottleneck[5]/relu_1"; +"346 ResNet/Sequential[layer3]/Bottleneck[5]/relu_1" -> "347 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1"; +"347 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_1" -> "350 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/conv2d_0"; +"348 layer3.5.conv3.weight" -> "349 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"349 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "350 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/conv2d_0"; +"350 ResNet/Sequential[layer3]/Bottleneck[5]/Conv2d[conv3]/conv2d_0" -> "353 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm_0"; +"351 layer3.5.bn3.weight" -> "353 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm_0"; +"352 layer3.5.bn3.bias" -> "353 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm_0"; +"353 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm_0" -> "354 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0"; +"354 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd___0" -> "355 ResNet/Sequential[layer3]/Bottleneck[5]/relu_2"; +"355 ResNet/Sequential[layer3]/Bottleneck[5]/relu_2" -> "356 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2"; +"356 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2" -> "359 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"356 ResNet/Sequential[layer3]/Bottleneck[5]/SymmetricQuantizer/symmetric_quantize_2" -> "381 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"357 layer4.0.conv1.weight" -> "358 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"358 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "359 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0"; +"359 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv1]/conv2d_0" -> "362 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"360 layer4.0.bn1.weight" -> "362 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"361 layer4.0.bn1.bias" -> "362 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0"; +"362 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm_0" -> "363 ResNet/Sequential[layer4]/Bottleneck[0]/relu_0"; +"363 ResNet/Sequential[layer4]/Bottleneck[0]/relu_0" -> "364 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0"; +"364 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_0" -> "367 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"365 layer4.0.conv2.weight" -> "366 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"366 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "367 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0"; +"367 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv2]/conv2d_0" -> "370 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"368 layer4.0.bn2.weight" -> "370 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"369 layer4.0.bn2.bias" -> "370 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0"; +"370 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm_0" -> "371 ResNet/Sequential[layer4]/Bottleneck[0]/relu_1"; +"371 ResNet/Sequential[layer4]/Bottleneck[0]/relu_1" -> "372 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1"; +"372 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_1" -> "375 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"373 layer4.0.conv3.weight" -> "374 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"374 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "375 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/conv2d_0"; +"375 ResNet/Sequential[layer4]/Bottleneck[0]/Conv2d[conv3]/conv2d_0" -> "378 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"376 layer4.0.bn3.weight" -> "378 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"377 layer4.0.bn3.bias" -> "378 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0"; +"378 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm_0" -> "386 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0"; +"379 layer4.0.shortcut.0.weight" -> "380 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"380 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "381 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0"; +"381 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/Conv2d[0]/conv2d_0" -> "384 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"382 layer4.0.shortcut.1.weight" -> "384 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"383 layer4.0.shortcut.1.bias" -> "384 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0"; +"384 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/batch_norm_0" -> "385 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"385 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[shortcut]/BatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "386 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0"; +"386 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd___0" -> "387 ResNet/Sequential[layer4]/Bottleneck[0]/relu_2"; +"387 ResNet/Sequential[layer4]/Bottleneck[0]/relu_2" -> "388 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2"; +"388 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "391 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"388 ResNet/Sequential[layer4]/Bottleneck[0]/SymmetricQuantizer/symmetric_quantize_2" -> "411 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0"; +"389 layer4.1.conv1.weight" -> "390 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"390 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "391 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0"; +"391 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv1]/conv2d_0" -> "394 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"392 layer4.1.bn1.weight" -> "394 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"393 layer4.1.bn1.bias" -> "394 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0"; +"394 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm_0" -> "395 ResNet/Sequential[layer4]/Bottleneck[1]/relu_0"; +"395 ResNet/Sequential[layer4]/Bottleneck[1]/relu_0" -> "396 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0"; +"396 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_0" -> "399 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"397 layer4.1.conv2.weight" -> "398 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"398 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "399 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0"; +"399 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv2]/conv2d_0" -> "402 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"400 layer4.1.bn2.weight" -> "402 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"401 layer4.1.bn2.bias" -> "402 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0"; +"402 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm_0" -> "403 ResNet/Sequential[layer4]/Bottleneck[1]/relu_1"; +"403 ResNet/Sequential[layer4]/Bottleneck[1]/relu_1" -> "404 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1"; +"404 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_1" -> "407 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"405 layer4.1.conv3.weight" -> "406 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"406 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "407 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/conv2d_0"; +"407 ResNet/Sequential[layer4]/Bottleneck[1]/Conv2d[conv3]/conv2d_0" -> "410 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"408 layer4.1.bn3.weight" -> "410 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"409 layer4.1.bn3.bias" -> "410 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0"; +"410 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm_0" -> "411 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0"; +"411 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd___0" -> "412 ResNet/Sequential[layer4]/Bottleneck[1]/relu_2"; +"412 ResNet/Sequential[layer4]/Bottleneck[1]/relu_2" -> "413 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2"; +"413 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "416 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"413 ResNet/Sequential[layer4]/Bottleneck[1]/SymmetricQuantizer/symmetric_quantize_2" -> "436 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0"; +"414 layer4.2.conv1.weight" -> "415 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"415 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "416 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0"; +"416 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv1]/conv2d_0" -> "419 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"417 layer4.2.bn1.weight" -> "419 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"418 layer4.2.bn1.bias" -> "419 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0"; +"419 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm_0" -> "420 ResNet/Sequential[layer4]/Bottleneck[2]/relu_0"; +"420 ResNet/Sequential[layer4]/Bottleneck[2]/relu_0" -> "421 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0"; +"421 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_0" -> "424 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"422 layer4.2.conv2.weight" -> "423 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"423 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "424 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0"; +"424 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv2]/conv2d_0" -> "427 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"425 layer4.2.bn2.weight" -> "427 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"426 layer4.2.bn2.bias" -> "427 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0"; +"427 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm_0" -> "428 ResNet/Sequential[layer4]/Bottleneck[2]/relu_1"; +"428 ResNet/Sequential[layer4]/Bottleneck[2]/relu_1" -> "429 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1"; +"429 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_1" -> "432 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"430 layer4.2.conv3.weight" -> "431 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"431 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "432 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/conv2d_0"; +"432 ResNet/Sequential[layer4]/Bottleneck[2]/Conv2d[conv3]/conv2d_0" -> "435 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"433 layer4.2.bn3.weight" -> "435 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"434 layer4.2.bn3.bias" -> "435 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0"; +"435 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm_0" -> "436 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0"; +"436 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd___0" -> "437 ResNet/Sequential[layer4]/Bottleneck[2]/relu_2"; +"437 ResNet/Sequential[layer4]/Bottleneck[2]/relu_2" -> "438 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2"; +"438 ResNet/Sequential[layer4]/Bottleneck[2]/SymmetricQuantizer/symmetric_quantize_2" -> "439 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0"; +"439 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d_0" -> "440 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0"; +"440 ResNet/AdaptiveAvgPool2d[avgpool]/SymmetricQuantizer/symmetric_quantize_0" -> "441 ResNet/flatten_0"; +"441 ResNet/flatten_0" -> "445 ResNet/Linear[linear]/linear_0"; +"442 linear.weight" -> "444 ResNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0"; +"443 linear.bias" -> "445 ResNet/Linear[linear]/linear_0"; +"444 ResNet/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" -> "445 ResNet/Linear[linear]/linear_0"; +"445 ResNet/Linear[linear]/linear_0" -> "446 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shared_model.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shared_model.dot index 137e293abdd..2e6ed74b24c 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shared_model.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shared_model.dot @@ -1,21 +1,25 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 SharedLayersModel/NNCFConv2d[shared_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_0" [id=3, type=conv2d]; -"4 SharedLayersModel/__add___0" [id=4, type=__add__]; -"5 SharedLayersModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[SharedLayersModel/__add___0|OUTPUT]/symmetric_quantize_0" [id=5, type=symmetric_quantize]; -"6 SharedLayersModel/NNCFConv2d[shared_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=6, type=symmetric_quantize]; -"7 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_1" [id=7, type=conv2d]; -"8 SharedLayersModel/__mul___0" [id=8, type=__mul__]; -"9 /nncf_model_output_0" [id=9, type=nncf_model_output]; +"2 shared_conv.weight" [id=2, type=nncf_model_const]; +"3 shared_conv.bias" [id=3, type=nncf_model_const]; +"4 SharedLayersModel/Conv2d[shared_conv]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 SharedLayersModel/Conv2d[shared_conv]/conv2d_0" [id=5, type=conv2d]; +"6 SharedLayersModel/__add___0" [id=6, type=__add__]; +"7 SharedLayersModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[SharedLayersModel/__add___0|OUTPUT]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 SharedLayersModel/Conv2d[shared_conv]/conv2d_1" [id=8, type=conv2d]; +"9 SharedLayersModel/__mul___0" [id=9, type=__mul__]; +"10 /nncf_model_output_0" [id=10, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_0"; -"2 SharedLayersModel/NNCFConv2d[shared_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_0"; -"3 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_0" -> "4 SharedLayersModel/__add___0"; -"4 SharedLayersModel/__add___0" -> "5 SharedLayersModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[SharedLayersModel/__add___0|OUTPUT]/symmetric_quantize_0"; -"5 SharedLayersModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[SharedLayersModel/__add___0|OUTPUT]/symmetric_quantize_0" -> "7 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_1"; -"6 SharedLayersModel/NNCFConv2d[shared_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "7 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_1"; -"7 SharedLayersModel/NNCFConv2d[shared_conv]/conv2d_1" -> "8 SharedLayersModel/__mul___0"; -"8 SharedLayersModel/__mul___0" -> "9 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 SharedLayersModel/Conv2d[shared_conv]/conv2d_0"; +"2 shared_conv.weight" -> "4 SharedLayersModel/Conv2d[shared_conv]/SymmetricQuantizer/symmetric_quantize_0"; +"2 shared_conv.weight" -> "8 SharedLayersModel/Conv2d[shared_conv]/conv2d_1"; +"3 shared_conv.bias" -> "5 SharedLayersModel/Conv2d[shared_conv]/conv2d_0"; +"3 shared_conv.bias" -> "8 SharedLayersModel/Conv2d[shared_conv]/conv2d_1"; +"4 SharedLayersModel/Conv2d[shared_conv]/SymmetricQuantizer/symmetric_quantize_0" -> "5 SharedLayersModel/Conv2d[shared_conv]/conv2d_0"; +"5 SharedLayersModel/Conv2d[shared_conv]/conv2d_0" -> "6 SharedLayersModel/__add___0" [label="parallel_input_port_ids:[1]"]; +"6 SharedLayersModel/__add___0" -> "7 SharedLayersModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[SharedLayersModel/__add___0|OUTPUT]/symmetric_quantize_0"; +"7 SharedLayersModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[SharedLayersModel/__add___0|OUTPUT]/symmetric_quantize_0" -> "8 SharedLayersModel/Conv2d[shared_conv]/conv2d_1"; +"8 SharedLayersModel/Conv2d[shared_conv]/conv2d_1" -> "9 SharedLayersModel/__mul___0" [label="parallel_input_port_ids:[1]"]; +"9 SharedLayersModel/__mul___0" -> "10 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shufflenetv2.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shufflenetv2.dot index a7dd9b2d274..f29d6b3fcca 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shufflenetv2.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/shufflenetv2.dot @@ -1,735 +1,1075 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 ShuffleNetV2/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 ShuffleNetV2/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; -"4 ShuffleNetV2/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=4, type=batch_norm]; -"5 ShuffleNetV2/relu_0" [id=5, type=relu]; -"6 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=8, type=conv2d]; -"9 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=9, type=batch_norm]; -"10 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; -"11 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=12, type=conv2d]; -"13 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=13, type=batch_norm]; -"14 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_0" [id=14, type=relu]; -"15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=15, type=symmetric_quantize]; -"16 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0" [id=17, type=conv2d]; -"18 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=18, type=batch_norm]; -"19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_1" [id=19, type=relu]; -"20 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=20, type=symmetric_quantize]; -"21 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0" [id=22, type=conv2d]; -"23 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0" [id=23, type=batch_norm]; -"24 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0" [id=26, type=conv2d]; -"27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0" [id=27, type=batch_norm]; -"28 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_2" [id=28, type=relu]; -"29 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" [id=29, type=symmetric_quantize]; -"30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0" [id=30, type=cat]; -"31 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" [id=31, type=view]; -"32 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" [id=32, type=permute]; -"33 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" [id=33, type=reshape]; -"34 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___0" [id=34, type=__getitem__]; -"35 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___1" [id=35, type=__getitem__]; -"36 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=36, type=symmetric_quantize]; -"37 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=37, type=conv2d]; -"38 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=38, type=batch_norm]; -"39 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_0" [id=39, type=relu]; -"40 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=40, type=symmetric_quantize]; -"41 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=41, type=symmetric_quantize]; -"42 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=42, type=conv2d]; -"43 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=43, type=batch_norm]; -"44 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=45, type=symmetric_quantize]; -"46 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0" [id=46, type=conv2d]; -"47 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=47, type=batch_norm]; -"48 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_1" [id=48, type=relu]; -"49 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=49, type=symmetric_quantize]; -"50 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0" [id=50, type=cat]; -"51 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" [id=51, type=view]; -"52 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" [id=52, type=permute]; -"53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" [id=53, type=reshape]; -"54 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___0" [id=54, type=__getitem__]; -"55 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___1" [id=55, type=__getitem__]; -"56 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; -"57 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0" [id=57, type=conv2d]; -"58 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=58, type=batch_norm]; -"59 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_0" [id=59, type=relu]; -"60 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; -"61 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; -"62 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0" [id=62, type=conv2d]; -"63 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=63, type=batch_norm]; -"64 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0" [id=66, type=conv2d]; -"67 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=67, type=batch_norm]; -"68 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_1" [id=68, type=relu]; -"69 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" [id=69, type=symmetric_quantize]; -"70 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0" [id=70, type=cat]; -"71 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" [id=71, type=view]; -"72 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" [id=72, type=permute]; -"73 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" [id=73, type=reshape]; -"74 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___0" [id=74, type=__getitem__]; -"75 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___1" [id=75, type=__getitem__]; -"76 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=76, type=symmetric_quantize]; -"77 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0" [id=77, type=conv2d]; -"78 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=78, type=batch_norm]; -"79 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_0" [id=79, type=relu]; -"80 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; -"82 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0" [id=82, type=conv2d]; -"83 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=83, type=batch_norm]; -"84 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; -"85 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0" [id=86, type=conv2d]; -"87 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=87, type=batch_norm]; -"88 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_1" [id=88, type=relu]; -"89 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" [id=89, type=symmetric_quantize]; -"90 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0" [id=90, type=cat]; -"91 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" [id=91, type=view]; -"92 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" [id=92, type=permute]; -"93 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" [id=93, type=reshape]; -"94 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=94, type=symmetric_quantize]; -"95 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=95, type=conv2d]; -"96 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=96, type=batch_norm]; -"97 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; -"98 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=98, type=symmetric_quantize]; -"99 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=99, type=conv2d]; -"100 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=100, type=batch_norm]; -"101 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_0" [id=101, type=relu]; -"102 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=102, type=symmetric_quantize]; -"103 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=103, type=symmetric_quantize]; -"104 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0" [id=104, type=conv2d]; -"105 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=105, type=batch_norm]; -"106 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_1" [id=106, type=relu]; -"107 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=107, type=symmetric_quantize]; -"108 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=108, type=symmetric_quantize]; -"109 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0" [id=109, type=conv2d]; -"110 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0" [id=110, type=batch_norm]; -"111 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=112, type=symmetric_quantize]; -"113 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0" [id=113, type=conv2d]; -"114 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0" [id=114, type=batch_norm]; -"115 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_2" [id=115, type=relu]; -"116 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" [id=116, type=symmetric_quantize]; -"117 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0" [id=117, type=cat]; -"118 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" [id=118, type=view]; -"119 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" [id=119, type=permute]; -"120 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" [id=120, type=reshape]; -"121 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___0" [id=121, type=__getitem__]; -"122 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___1" [id=122, type=__getitem__]; -"123 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=123, type=symmetric_quantize]; -"124 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=124, type=conv2d]; -"125 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=125, type=batch_norm]; -"126 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_0" [id=126, type=relu]; -"127 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=127, type=symmetric_quantize]; -"128 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=128, type=symmetric_quantize]; -"129 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=129, type=conv2d]; -"130 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=130, type=batch_norm]; -"131 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; -"132 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=132, type=symmetric_quantize]; -"133 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0" [id=133, type=conv2d]; -"134 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=134, type=batch_norm]; -"135 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_1" [id=135, type=relu]; -"136 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=136, type=symmetric_quantize]; -"137 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0" [id=137, type=cat]; -"138 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" [id=138, type=view]; -"139 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" [id=139, type=permute]; -"140 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" [id=140, type=reshape]; -"141 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___0" [id=141, type=__getitem__]; -"142 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___1" [id=142, type=__getitem__]; -"143 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=143, type=symmetric_quantize]; -"144 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0" [id=144, type=conv2d]; -"145 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=145, type=batch_norm]; -"146 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_0" [id=146, type=relu]; -"147 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; -"148 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0" [id=149, type=conv2d]; -"150 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=150, type=batch_norm]; -"151 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=151, type=symmetric_quantize]; -"152 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=152, type=symmetric_quantize]; -"153 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0" [id=153, type=conv2d]; -"154 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=154, type=batch_norm]; -"155 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_1" [id=155, type=relu]; -"156 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" [id=156, type=symmetric_quantize]; -"157 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0" [id=157, type=cat]; -"158 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" [id=158, type=view]; -"159 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" [id=159, type=permute]; -"160 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" [id=160, type=reshape]; -"161 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___0" [id=161, type=__getitem__]; -"162 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___1" [id=162, type=__getitem__]; -"163 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=163, type=symmetric_quantize]; -"164 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0" [id=164, type=conv2d]; -"165 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=165, type=batch_norm]; -"166 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_0" [id=166, type=relu]; -"167 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" [id=167, type=symmetric_quantize]; -"168 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=168, type=symmetric_quantize]; -"169 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0" [id=169, type=conv2d]; -"170 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=170, type=batch_norm]; -"171 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=171, type=symmetric_quantize]; -"172 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=172, type=symmetric_quantize]; -"173 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0" [id=173, type=conv2d]; -"174 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=174, type=batch_norm]; -"175 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_1" [id=175, type=relu]; -"176 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" [id=176, type=symmetric_quantize]; -"177 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0" [id=177, type=cat]; -"178 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" [id=178, type=view]; -"179 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" [id=179, type=permute]; -"180 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" [id=180, type=reshape]; -"181 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___0" [id=181, type=__getitem__]; -"182 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___1" [id=182, type=__getitem__]; -"183 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=183, type=symmetric_quantize]; -"184 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv1]/conv2d_0" [id=184, type=conv2d]; -"185 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=185, type=batch_norm]; -"186 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_0" [id=186, type=relu]; -"187 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_0" [id=187, type=symmetric_quantize]; -"188 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=188, type=symmetric_quantize]; -"189 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv2]/conv2d_0" [id=189, type=conv2d]; -"190 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=190, type=batch_norm]; -"191 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=191, type=symmetric_quantize]; -"192 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=192, type=symmetric_quantize]; -"193 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv3]/conv2d_0" [id=193, type=conv2d]; -"194 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=194, type=batch_norm]; -"195 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_1" [id=195, type=relu]; -"196 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_1" [id=196, type=symmetric_quantize]; -"197 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0" [id=197, type=cat]; -"198 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/view_0" [id=198, type=view]; -"199 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/permute_0" [id=199, type=permute]; -"200 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0" [id=200, type=reshape]; -"201 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___0" [id=201, type=__getitem__]; -"202 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___1" [id=202, type=__getitem__]; -"203 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=203, type=symmetric_quantize]; -"204 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv1]/conv2d_0" [id=204, type=conv2d]; -"205 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=205, type=batch_norm]; -"206 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_0" [id=206, type=relu]; -"207 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; -"208 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=208, type=symmetric_quantize]; -"209 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv2]/conv2d_0" [id=209, type=conv2d]; -"210 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=210, type=batch_norm]; -"211 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=211, type=symmetric_quantize]; -"212 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=212, type=symmetric_quantize]; -"213 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv3]/conv2d_0" [id=213, type=conv2d]; -"214 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=214, type=batch_norm]; -"215 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_1" [id=215, type=relu]; -"216 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_1" [id=216, type=symmetric_quantize]; -"217 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0" [id=217, type=cat]; -"218 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/view_0" [id=218, type=view]; -"219 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/permute_0" [id=219, type=permute]; -"220 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0" [id=220, type=reshape]; -"221 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___0" [id=221, type=__getitem__]; -"222 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___1" [id=222, type=__getitem__]; -"223 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=223, type=symmetric_quantize]; -"224 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv1]/conv2d_0" [id=224, type=conv2d]; -"225 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=225, type=batch_norm]; -"226 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_0" [id=226, type=relu]; -"227 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_0" [id=227, type=symmetric_quantize]; -"228 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=228, type=symmetric_quantize]; -"229 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv2]/conv2d_0" [id=229, type=conv2d]; -"230 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=230, type=batch_norm]; -"231 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=231, type=symmetric_quantize]; -"232 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=232, type=symmetric_quantize]; -"233 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv3]/conv2d_0" [id=233, type=conv2d]; -"234 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=234, type=batch_norm]; -"235 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_1" [id=235, type=relu]; -"236 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_1" [id=236, type=symmetric_quantize]; -"237 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0" [id=237, type=cat]; -"238 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/view_0" [id=238, type=view]; -"239 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/permute_0" [id=239, type=permute]; -"240 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0" [id=240, type=reshape]; -"241 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___0" [id=241, type=__getitem__]; -"242 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___1" [id=242, type=__getitem__]; -"243 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=243, type=symmetric_quantize]; -"244 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv1]/conv2d_0" [id=244, type=conv2d]; -"245 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=245, type=batch_norm]; -"246 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_0" [id=246, type=relu]; -"247 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_0" [id=247, type=symmetric_quantize]; -"248 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=248, type=symmetric_quantize]; -"249 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv2]/conv2d_0" [id=249, type=conv2d]; -"250 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=250, type=batch_norm]; -"251 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=251, type=symmetric_quantize]; -"252 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=252, type=symmetric_quantize]; -"253 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv3]/conv2d_0" [id=253, type=conv2d]; -"254 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=254, type=batch_norm]; -"255 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_1" [id=255, type=relu]; -"256 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_1" [id=256, type=symmetric_quantize]; -"257 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0" [id=257, type=cat]; -"258 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/view_0" [id=258, type=view]; -"259 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/permute_0" [id=259, type=permute]; -"260 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0" [id=260, type=reshape]; -"261 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=261, type=symmetric_quantize]; -"262 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0" [id=262, type=conv2d]; -"263 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=263, type=batch_norm]; -"264 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" [id=264, type=symmetric_quantize]; -"265 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=265, type=symmetric_quantize]; -"266 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0" [id=266, type=conv2d]; -"267 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=267, type=batch_norm]; -"268 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_0" [id=268, type=relu]; -"269 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=269, type=symmetric_quantize]; -"270 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=270, type=symmetric_quantize]; -"271 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0" [id=271, type=conv2d]; -"272 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=272, type=batch_norm]; -"273 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_1" [id=273, type=relu]; -"274 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=274, type=symmetric_quantize]; -"275 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=275, type=symmetric_quantize]; -"276 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0" [id=276, type=conv2d]; -"277 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0" [id=277, type=batch_norm]; -"278 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" [id=278, type=symmetric_quantize]; -"279 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=279, type=symmetric_quantize]; -"280 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0" [id=280, type=conv2d]; -"281 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0" [id=281, type=batch_norm]; -"282 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_2" [id=282, type=relu]; -"283 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" [id=283, type=symmetric_quantize]; -"284 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0" [id=284, type=cat]; -"285 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" [id=285, type=view]; -"286 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" [id=286, type=permute]; -"287 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" [id=287, type=reshape]; -"288 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___0" [id=288, type=__getitem__]; -"289 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___1" [id=289, type=__getitem__]; -"290 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=290, type=symmetric_quantize]; -"291 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" [id=291, type=conv2d]; -"292 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=292, type=batch_norm]; -"293 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_0" [id=293, type=relu]; -"294 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=294, type=symmetric_quantize]; -"295 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=295, type=symmetric_quantize]; -"296 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" [id=296, type=conv2d]; -"297 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=297, type=batch_norm]; -"298 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=298, type=symmetric_quantize]; -"299 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=299, type=symmetric_quantize]; -"300 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0" [id=300, type=conv2d]; -"301 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=301, type=batch_norm]; -"302 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_1" [id=302, type=relu]; -"303 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=303, type=symmetric_quantize]; -"304 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0" [id=304, type=cat]; -"305 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" [id=305, type=view]; -"306 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" [id=306, type=permute]; -"307 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" [id=307, type=reshape]; -"308 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___0" [id=308, type=__getitem__]; -"309 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___1" [id=309, type=__getitem__]; -"310 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=310, type=symmetric_quantize]; -"311 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0" [id=311, type=conv2d]; -"312 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=312, type=batch_norm]; -"313 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_0" [id=313, type=relu]; -"314 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" [id=314, type=symmetric_quantize]; -"315 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=315, type=symmetric_quantize]; -"316 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0" [id=316, type=conv2d]; -"317 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=317, type=batch_norm]; -"318 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=318, type=symmetric_quantize]; -"319 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=319, type=symmetric_quantize]; -"320 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0" [id=320, type=conv2d]; -"321 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=321, type=batch_norm]; -"322 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_1" [id=322, type=relu]; -"323 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" [id=323, type=symmetric_quantize]; -"324 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0" [id=324, type=cat]; -"325 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" [id=325, type=view]; -"326 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" [id=326, type=permute]; -"327 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" [id=327, type=reshape]; -"328 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___0" [id=328, type=__getitem__]; -"329 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___1" [id=329, type=__getitem__]; -"330 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=330, type=symmetric_quantize]; -"331 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0" [id=331, type=conv2d]; -"332 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=332, type=batch_norm]; -"333 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_0" [id=333, type=relu]; -"334 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" [id=334, type=symmetric_quantize]; -"335 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=335, type=symmetric_quantize]; -"336 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0" [id=336, type=conv2d]; -"337 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=337, type=batch_norm]; -"338 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=338, type=symmetric_quantize]; -"339 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=339, type=symmetric_quantize]; -"340 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0" [id=340, type=conv2d]; -"341 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=341, type=batch_norm]; -"342 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_1" [id=342, type=relu]; -"343 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" [id=343, type=symmetric_quantize]; -"344 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0" [id=344, type=cat]; -"345 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" [id=345, type=view]; -"346 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" [id=346, type=permute]; -"347 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" [id=347, type=reshape]; -"348 ShuffleNetV2/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=348, type=symmetric_quantize]; -"349 ShuffleNetV2/NNCFConv2d[conv2]/conv2d_0" [id=349, type=conv2d]; -"350 ShuffleNetV2/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=350, type=batch_norm]; -"351 ShuffleNetV2/relu_1" [id=351, type=relu]; -"352 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_1|OUTPUT]/symmetric_quantize_0" [id=352, type=symmetric_quantize]; -"353 ShuffleNetV2/avg_pool2d_0" [id=353, type=avg_pool2d]; -"354 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=354, type=symmetric_quantize]; -"355 ShuffleNetV2/view_0" [id=355, type=view]; -"356 ShuffleNetV2/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=356, type=symmetric_quantize]; -"357 ShuffleNetV2/NNCFLinear[linear]/linear_0" [id=357, type=linear]; -"358 /nncf_model_output_0" [id=358, type=nncf_model_output]; +"2 conv1.weight" [id=2, type=nncf_model_const]; +"3 ShuffleNetV2/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 ShuffleNetV2/Conv2d[conv1]/conv2d_0" [id=4, type=conv2d]; +"5 bn1.weight" [id=5, type=nncf_model_const]; +"6 bn1.bias" [id=6, type=nncf_model_const]; +"7 ShuffleNetV2/BatchNorm2d[bn1]/batch_norm_0" [id=7, type=batch_norm]; +"8 ShuffleNetV2/relu_0" [id=8, type=relu]; +"9 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0" [id=9, type=symmetric_quantize]; +"10 layer1.0.conv1.weight" [id=10, type=nncf_model_const]; +"11 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/conv2d_0" [id=12, type=conv2d]; +"13 layer1.0.bn1.weight" [id=13, type=nncf_model_const]; +"14 layer1.0.bn1.bias" [id=14, type=nncf_model_const]; +"15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=15, type=batch_norm]; +"16 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" [id=16, type=symmetric_quantize]; +"17 layer1.0.conv2.weight" [id=17, type=nncf_model_const]; +"18 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=18, type=symmetric_quantize]; +"19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/conv2d_0" [id=19, type=conv2d]; +"20 layer1.0.bn2.weight" [id=20, type=nncf_model_const]; +"21 layer1.0.bn2.bias" [id=21, type=nncf_model_const]; +"22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=22, type=batch_norm]; +"23 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_0" [id=23, type=relu]; +"24 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; +"25 layer1.0.conv3.weight" [id=25, type=nncf_model_const]; +"26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/conv2d_0" [id=27, type=conv2d]; +"28 layer1.0.bn3.weight" [id=28, type=nncf_model_const]; +"29 layer1.0.bn3.bias" [id=29, type=nncf_model_const]; +"30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0" [id=30, type=batch_norm]; +"31 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_1" [id=31, type=relu]; +"32 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=32, type=symmetric_quantize]; +"33 layer1.0.conv4.weight" [id=33, type=nncf_model_const]; +"34 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/conv2d_0" [id=35, type=conv2d]; +"36 layer1.0.bn4.weight" [id=36, type=nncf_model_const]; +"37 layer1.0.bn4.bias" [id=37, type=nncf_model_const]; +"38 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0" [id=38, type=batch_norm]; +"39 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 layer1.0.conv5.weight" [id=40, type=nncf_model_const]; +"41 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0" [id=41, type=symmetric_quantize]; +"42 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/conv2d_0" [id=42, type=conv2d]; +"43 layer1.0.bn5.weight" [id=43, type=nncf_model_const]; +"44 layer1.0.bn5.bias" [id=44, type=nncf_model_const]; +"45 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0" [id=45, type=batch_norm]; +"46 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_2" [id=46, type=relu]; +"47 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" [id=47, type=symmetric_quantize]; +"48 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0" [id=48, type=cat]; +"49 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" [id=49, type=view]; +"50 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" [id=50, type=permute]; +"51 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" [id=51, type=reshape]; +"52 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___0" [id=52, type=__getitem__]; +"53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___1" [id=53, type=__getitem__]; +"54 layer1.1.conv1.weight" [id=54, type=nncf_model_const]; +"55 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; +"56 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=56, type=conv2d]; +"57 layer1.1.bn1.weight" [id=57, type=nncf_model_const]; +"58 layer1.1.bn1.bias" [id=58, type=nncf_model_const]; +"59 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=59, type=batch_norm]; +"60 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_0" [id=60, type=relu]; +"61 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 layer1.1.conv2.weight" [id=62, type=nncf_model_const]; +"63 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; +"64 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=64, type=conv2d]; +"65 layer1.1.bn2.weight" [id=65, type=nncf_model_const]; +"66 layer1.1.bn2.bias" [id=66, type=nncf_model_const]; +"67 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=67, type=batch_norm]; +"68 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; +"69 layer1.1.conv3.weight" [id=69, type=nncf_model_const]; +"70 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/conv2d_0" [id=71, type=conv2d]; +"72 layer1.1.bn3.weight" [id=72, type=nncf_model_const]; +"73 layer1.1.bn3.bias" [id=73, type=nncf_model_const]; +"74 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0" [id=74, type=batch_norm]; +"75 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_1" [id=75, type=relu]; +"76 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=76, type=symmetric_quantize]; +"77 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0" [id=77, type=cat]; +"78 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" [id=78, type=view]; +"79 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" [id=79, type=permute]; +"80 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" [id=80, type=reshape]; +"81 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___0" [id=81, type=__getitem__]; +"82 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___1" [id=82, type=__getitem__]; +"83 layer1.2.conv1.weight" [id=83, type=nncf_model_const]; +"84 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/conv2d_0" [id=85, type=conv2d]; +"86 layer1.2.bn1.weight" [id=86, type=nncf_model_const]; +"87 layer1.2.bn1.bias" [id=87, type=nncf_model_const]; +"88 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0" [id=88, type=batch_norm]; +"89 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_0" [id=89, type=relu]; +"90 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" [id=90, type=symmetric_quantize]; +"91 layer1.2.conv2.weight" [id=91, type=nncf_model_const]; +"92 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=92, type=symmetric_quantize]; +"93 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/conv2d_0" [id=93, type=conv2d]; +"94 layer1.2.bn2.weight" [id=94, type=nncf_model_const]; +"95 layer1.2.bn2.bias" [id=95, type=nncf_model_const]; +"96 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0" [id=96, type=batch_norm]; +"97 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 layer1.2.conv3.weight" [id=98, type=nncf_model_const]; +"99 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=99, type=symmetric_quantize]; +"100 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/conv2d_0" [id=100, type=conv2d]; +"101 layer1.2.bn3.weight" [id=101, type=nncf_model_const]; +"102 layer1.2.bn3.bias" [id=102, type=nncf_model_const]; +"103 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0" [id=103, type=batch_norm]; +"104 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_1" [id=104, type=relu]; +"105 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" [id=105, type=symmetric_quantize]; +"106 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0" [id=106, type=cat]; +"107 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" [id=107, type=view]; +"108 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" [id=108, type=permute]; +"109 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" [id=109, type=reshape]; +"110 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___0" [id=110, type=__getitem__]; +"111 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___1" [id=111, type=__getitem__]; +"112 layer1.3.conv1.weight" [id=112, type=nncf_model_const]; +"113 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=113, type=symmetric_quantize]; +"114 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/conv2d_0" [id=114, type=conv2d]; +"115 layer1.3.bn1.weight" [id=115, type=nncf_model_const]; +"116 layer1.3.bn1.bias" [id=116, type=nncf_model_const]; +"117 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0" [id=117, type=batch_norm]; +"118 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_0" [id=118, type=relu]; +"119 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" [id=119, type=symmetric_quantize]; +"120 layer1.3.conv2.weight" [id=120, type=nncf_model_const]; +"121 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=121, type=symmetric_quantize]; +"122 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/conv2d_0" [id=122, type=conv2d]; +"123 layer1.3.bn2.weight" [id=123, type=nncf_model_const]; +"124 layer1.3.bn2.bias" [id=124, type=nncf_model_const]; +"125 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0" [id=125, type=batch_norm]; +"126 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; +"127 layer1.3.conv3.weight" [id=127, type=nncf_model_const]; +"128 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=128, type=symmetric_quantize]; +"129 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/conv2d_0" [id=129, type=conv2d]; +"130 layer1.3.bn3.weight" [id=130, type=nncf_model_const]; +"131 layer1.3.bn3.bias" [id=131, type=nncf_model_const]; +"132 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0" [id=132, type=batch_norm]; +"133 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_1" [id=133, type=relu]; +"134 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" [id=134, type=symmetric_quantize]; +"135 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0" [id=135, type=cat]; +"136 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" [id=136, type=view]; +"137 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" [id=137, type=permute]; +"138 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" [id=138, type=reshape]; +"139 layer2.0.conv1.weight" [id=139, type=nncf_model_const]; +"140 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/conv2d_0" [id=141, type=conv2d]; +"142 layer2.0.bn1.weight" [id=142, type=nncf_model_const]; +"143 layer2.0.bn1.bias" [id=143, type=nncf_model_const]; +"144 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=144, type=batch_norm]; +"145 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 layer2.0.conv2.weight" [id=146, type=nncf_model_const]; +"147 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=147, type=symmetric_quantize]; +"148 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/conv2d_0" [id=148, type=conv2d]; +"149 layer2.0.bn2.weight" [id=149, type=nncf_model_const]; +"150 layer2.0.bn2.bias" [id=150, type=nncf_model_const]; +"151 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=151, type=batch_norm]; +"152 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_0" [id=152, type=relu]; +"153 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=153, type=symmetric_quantize]; +"154 layer2.0.conv3.weight" [id=154, type=nncf_model_const]; +"155 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; +"156 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/conv2d_0" [id=156, type=conv2d]; +"157 layer2.0.bn3.weight" [id=157, type=nncf_model_const]; +"158 layer2.0.bn3.bias" [id=158, type=nncf_model_const]; +"159 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0" [id=159, type=batch_norm]; +"160 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_1" [id=160, type=relu]; +"161 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=161, type=symmetric_quantize]; +"162 layer2.0.conv4.weight" [id=162, type=nncf_model_const]; +"163 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0" [id=163, type=symmetric_quantize]; +"164 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/conv2d_0" [id=164, type=conv2d]; +"165 layer2.0.bn4.weight" [id=165, type=nncf_model_const]; +"166 layer2.0.bn4.bias" [id=166, type=nncf_model_const]; +"167 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0" [id=167, type=batch_norm]; +"168 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" [id=168, type=symmetric_quantize]; +"169 layer2.0.conv5.weight" [id=169, type=nncf_model_const]; +"170 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0" [id=170, type=symmetric_quantize]; +"171 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/conv2d_0" [id=171, type=conv2d]; +"172 layer2.0.bn5.weight" [id=172, type=nncf_model_const]; +"173 layer2.0.bn5.bias" [id=173, type=nncf_model_const]; +"174 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0" [id=174, type=batch_norm]; +"175 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_2" [id=175, type=relu]; +"176 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" [id=176, type=symmetric_quantize]; +"177 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0" [id=177, type=cat]; +"178 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" [id=178, type=view]; +"179 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" [id=179, type=permute]; +"180 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" [id=180, type=reshape]; +"181 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___0" [id=181, type=__getitem__]; +"182 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___1" [id=182, type=__getitem__]; +"183 layer2.1.conv1.weight" [id=183, type=nncf_model_const]; +"184 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=184, type=symmetric_quantize]; +"185 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=185, type=conv2d]; +"186 layer2.1.bn1.weight" [id=186, type=nncf_model_const]; +"187 layer2.1.bn1.bias" [id=187, type=nncf_model_const]; +"188 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=188, type=batch_norm]; +"189 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_0" [id=189, type=relu]; +"190 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=190, type=symmetric_quantize]; +"191 layer2.1.conv2.weight" [id=191, type=nncf_model_const]; +"192 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=192, type=symmetric_quantize]; +"193 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=193, type=conv2d]; +"194 layer2.1.bn2.weight" [id=194, type=nncf_model_const]; +"195 layer2.1.bn2.bias" [id=195, type=nncf_model_const]; +"196 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=196, type=batch_norm]; +"197 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=197, type=symmetric_quantize]; +"198 layer2.1.conv3.weight" [id=198, type=nncf_model_const]; +"199 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=199, type=symmetric_quantize]; +"200 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/conv2d_0" [id=200, type=conv2d]; +"201 layer2.1.bn3.weight" [id=201, type=nncf_model_const]; +"202 layer2.1.bn3.bias" [id=202, type=nncf_model_const]; +"203 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0" [id=203, type=batch_norm]; +"204 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_1" [id=204, type=relu]; +"205 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=205, type=symmetric_quantize]; +"206 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0" [id=206, type=cat]; +"207 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" [id=207, type=view]; +"208 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" [id=208, type=permute]; +"209 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" [id=209, type=reshape]; +"210 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___0" [id=210, type=__getitem__]; +"211 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___1" [id=211, type=__getitem__]; +"212 layer2.2.conv1.weight" [id=212, type=nncf_model_const]; +"213 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=213, type=symmetric_quantize]; +"214 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/conv2d_0" [id=214, type=conv2d]; +"215 layer2.2.bn1.weight" [id=215, type=nncf_model_const]; +"216 layer2.2.bn1.bias" [id=216, type=nncf_model_const]; +"217 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0" [id=217, type=batch_norm]; +"218 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_0" [id=218, type=relu]; +"219 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" [id=219, type=symmetric_quantize]; +"220 layer2.2.conv2.weight" [id=220, type=nncf_model_const]; +"221 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=221, type=symmetric_quantize]; +"222 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/conv2d_0" [id=222, type=conv2d]; +"223 layer2.2.bn2.weight" [id=223, type=nncf_model_const]; +"224 layer2.2.bn2.bias" [id=224, type=nncf_model_const]; +"225 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0" [id=225, type=batch_norm]; +"226 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=226, type=symmetric_quantize]; +"227 layer2.2.conv3.weight" [id=227, type=nncf_model_const]; +"228 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/conv2d_0" [id=229, type=conv2d]; +"230 layer2.2.bn3.weight" [id=230, type=nncf_model_const]; +"231 layer2.2.bn3.bias" [id=231, type=nncf_model_const]; +"232 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0" [id=232, type=batch_norm]; +"233 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_1" [id=233, type=relu]; +"234 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" [id=234, type=symmetric_quantize]; +"235 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0" [id=235, type=cat]; +"236 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" [id=236, type=view]; +"237 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" [id=237, type=permute]; +"238 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" [id=238, type=reshape]; +"239 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___0" [id=239, type=__getitem__]; +"240 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___1" [id=240, type=__getitem__]; +"241 layer2.3.conv1.weight" [id=241, type=nncf_model_const]; +"242 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=242, type=symmetric_quantize]; +"243 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/conv2d_0" [id=243, type=conv2d]; +"244 layer2.3.bn1.weight" [id=244, type=nncf_model_const]; +"245 layer2.3.bn1.bias" [id=245, type=nncf_model_const]; +"246 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0" [id=246, type=batch_norm]; +"247 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_0" [id=247, type=relu]; +"248 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" [id=248, type=symmetric_quantize]; +"249 layer2.3.conv2.weight" [id=249, type=nncf_model_const]; +"250 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=250, type=symmetric_quantize]; +"251 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/conv2d_0" [id=251, type=conv2d]; +"252 layer2.3.bn2.weight" [id=252, type=nncf_model_const]; +"253 layer2.3.bn2.bias" [id=253, type=nncf_model_const]; +"254 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0" [id=254, type=batch_norm]; +"255 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 layer2.3.conv3.weight" [id=256, type=nncf_model_const]; +"257 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=257, type=symmetric_quantize]; +"258 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/conv2d_0" [id=258, type=conv2d]; +"259 layer2.3.bn3.weight" [id=259, type=nncf_model_const]; +"260 layer2.3.bn3.bias" [id=260, type=nncf_model_const]; +"261 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0" [id=261, type=batch_norm]; +"262 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_1" [id=262, type=relu]; +"263 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" [id=263, type=symmetric_quantize]; +"264 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0" [id=264, type=cat]; +"265 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" [id=265, type=view]; +"266 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" [id=266, type=permute]; +"267 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" [id=267, type=reshape]; +"268 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___0" [id=268, type=__getitem__]; +"269 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___1" [id=269, type=__getitem__]; +"270 layer2.4.conv1.weight" [id=270, type=nncf_model_const]; +"271 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=271, type=symmetric_quantize]; +"272 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/conv2d_0" [id=272, type=conv2d]; +"273 layer2.4.bn1.weight" [id=273, type=nncf_model_const]; +"274 layer2.4.bn1.bias" [id=274, type=nncf_model_const]; +"275 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn1]/batch_norm_0" [id=275, type=batch_norm]; +"276 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_0" [id=276, type=relu]; +"277 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_0" [id=277, type=symmetric_quantize]; +"278 layer2.4.conv2.weight" [id=278, type=nncf_model_const]; +"279 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=279, type=symmetric_quantize]; +"280 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/conv2d_0" [id=280, type=conv2d]; +"281 layer2.4.bn2.weight" [id=281, type=nncf_model_const]; +"282 layer2.4.bn2.bias" [id=282, type=nncf_model_const]; +"283 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/batch_norm_0" [id=283, type=batch_norm]; +"284 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 layer2.4.conv3.weight" [id=285, type=nncf_model_const]; +"286 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=286, type=symmetric_quantize]; +"287 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/conv2d_0" [id=287, type=conv2d]; +"288 layer2.4.bn3.weight" [id=288, type=nncf_model_const]; +"289 layer2.4.bn3.bias" [id=289, type=nncf_model_const]; +"290 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn3]/batch_norm_0" [id=290, type=batch_norm]; +"291 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_1" [id=291, type=relu]; +"292 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_1" [id=292, type=symmetric_quantize]; +"293 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0" [id=293, type=cat]; +"294 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/view_0" [id=294, type=view]; +"295 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/permute_0" [id=295, type=permute]; +"296 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0" [id=296, type=reshape]; +"297 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___0" [id=297, type=__getitem__]; +"298 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___1" [id=298, type=__getitem__]; +"299 layer2.5.conv1.weight" [id=299, type=nncf_model_const]; +"300 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=300, type=symmetric_quantize]; +"301 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/conv2d_0" [id=301, type=conv2d]; +"302 layer2.5.bn1.weight" [id=302, type=nncf_model_const]; +"303 layer2.5.bn1.bias" [id=303, type=nncf_model_const]; +"304 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn1]/batch_norm_0" [id=304, type=batch_norm]; +"305 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_0" [id=305, type=relu]; +"306 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_0" [id=306, type=symmetric_quantize]; +"307 layer2.5.conv2.weight" [id=307, type=nncf_model_const]; +"308 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=308, type=symmetric_quantize]; +"309 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/conv2d_0" [id=309, type=conv2d]; +"310 layer2.5.bn2.weight" [id=310, type=nncf_model_const]; +"311 layer2.5.bn2.bias" [id=311, type=nncf_model_const]; +"312 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/batch_norm_0" [id=312, type=batch_norm]; +"313 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=313, type=symmetric_quantize]; +"314 layer2.5.conv3.weight" [id=314, type=nncf_model_const]; +"315 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=315, type=symmetric_quantize]; +"316 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/conv2d_0" [id=316, type=conv2d]; +"317 layer2.5.bn3.weight" [id=317, type=nncf_model_const]; +"318 layer2.5.bn3.bias" [id=318, type=nncf_model_const]; +"319 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn3]/batch_norm_0" [id=319, type=batch_norm]; +"320 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_1" [id=320, type=relu]; +"321 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_1" [id=321, type=symmetric_quantize]; +"322 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0" [id=322, type=cat]; +"323 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/view_0" [id=323, type=view]; +"324 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/permute_0" [id=324, type=permute]; +"325 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0" [id=325, type=reshape]; +"326 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___0" [id=326, type=__getitem__]; +"327 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___1" [id=327, type=__getitem__]; +"328 layer2.6.conv1.weight" [id=328, type=nncf_model_const]; +"329 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; +"330 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/conv2d_0" [id=330, type=conv2d]; +"331 layer2.6.bn1.weight" [id=331, type=nncf_model_const]; +"332 layer2.6.bn1.bias" [id=332, type=nncf_model_const]; +"333 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn1]/batch_norm_0" [id=333, type=batch_norm]; +"334 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_0" [id=334, type=relu]; +"335 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 layer2.6.conv2.weight" [id=336, type=nncf_model_const]; +"337 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/conv2d_0" [id=338, type=conv2d]; +"339 layer2.6.bn2.weight" [id=339, type=nncf_model_const]; +"340 layer2.6.bn2.bias" [id=340, type=nncf_model_const]; +"341 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/batch_norm_0" [id=341, type=batch_norm]; +"342 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=342, type=symmetric_quantize]; +"343 layer2.6.conv3.weight" [id=343, type=nncf_model_const]; +"344 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=344, type=symmetric_quantize]; +"345 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/conv2d_0" [id=345, type=conv2d]; +"346 layer2.6.bn3.weight" [id=346, type=nncf_model_const]; +"347 layer2.6.bn3.bias" [id=347, type=nncf_model_const]; +"348 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn3]/batch_norm_0" [id=348, type=batch_norm]; +"349 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_1" [id=349, type=relu]; +"350 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_1" [id=350, type=symmetric_quantize]; +"351 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0" [id=351, type=cat]; +"352 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/view_0" [id=352, type=view]; +"353 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/permute_0" [id=353, type=permute]; +"354 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0" [id=354, type=reshape]; +"355 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___0" [id=355, type=__getitem__]; +"356 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___1" [id=356, type=__getitem__]; +"357 layer2.7.conv1.weight" [id=357, type=nncf_model_const]; +"358 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=358, type=symmetric_quantize]; +"359 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/conv2d_0" [id=359, type=conv2d]; +"360 layer2.7.bn1.weight" [id=360, type=nncf_model_const]; +"361 layer2.7.bn1.bias" [id=361, type=nncf_model_const]; +"362 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn1]/batch_norm_0" [id=362, type=batch_norm]; +"363 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_0" [id=363, type=relu]; +"364 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_0" [id=364, type=symmetric_quantize]; +"365 layer2.7.conv2.weight" [id=365, type=nncf_model_const]; +"366 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=366, type=symmetric_quantize]; +"367 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/conv2d_0" [id=367, type=conv2d]; +"368 layer2.7.bn2.weight" [id=368, type=nncf_model_const]; +"369 layer2.7.bn2.bias" [id=369, type=nncf_model_const]; +"370 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/batch_norm_0" [id=370, type=batch_norm]; +"371 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=371, type=symmetric_quantize]; +"372 layer2.7.conv3.weight" [id=372, type=nncf_model_const]; +"373 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=373, type=symmetric_quantize]; +"374 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/conv2d_0" [id=374, type=conv2d]; +"375 layer2.7.bn3.weight" [id=375, type=nncf_model_const]; +"376 layer2.7.bn3.bias" [id=376, type=nncf_model_const]; +"377 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn3]/batch_norm_0" [id=377, type=batch_norm]; +"378 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_1" [id=378, type=relu]; +"379 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_1" [id=379, type=symmetric_quantize]; +"380 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0" [id=380, type=cat]; +"381 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/view_0" [id=381, type=view]; +"382 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/permute_0" [id=382, type=permute]; +"383 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0" [id=383, type=reshape]; +"384 layer3.0.conv1.weight" [id=384, type=nncf_model_const]; +"385 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=385, type=symmetric_quantize]; +"386 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/conv2d_0" [id=386, type=conv2d]; +"387 layer3.0.bn1.weight" [id=387, type=nncf_model_const]; +"388 layer3.0.bn1.bias" [id=388, type=nncf_model_const]; +"389 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0" [id=389, type=batch_norm]; +"390 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" [id=390, type=symmetric_quantize]; +"391 layer3.0.conv2.weight" [id=391, type=nncf_model_const]; +"392 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=392, type=symmetric_quantize]; +"393 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/conv2d_0" [id=393, type=conv2d]; +"394 layer3.0.bn2.weight" [id=394, type=nncf_model_const]; +"395 layer3.0.bn2.bias" [id=395, type=nncf_model_const]; +"396 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0" [id=396, type=batch_norm]; +"397 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_0" [id=397, type=relu]; +"398 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" [id=398, type=symmetric_quantize]; +"399 layer3.0.conv3.weight" [id=399, type=nncf_model_const]; +"400 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=400, type=symmetric_quantize]; +"401 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/conv2d_0" [id=401, type=conv2d]; +"402 layer3.0.bn3.weight" [id=402, type=nncf_model_const]; +"403 layer3.0.bn3.bias" [id=403, type=nncf_model_const]; +"404 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0" [id=404, type=batch_norm]; +"405 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_1" [id=405, type=relu]; +"406 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" [id=406, type=symmetric_quantize]; +"407 layer3.0.conv4.weight" [id=407, type=nncf_model_const]; +"408 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0" [id=408, type=symmetric_quantize]; +"409 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/conv2d_0" [id=409, type=conv2d]; +"410 layer3.0.bn4.weight" [id=410, type=nncf_model_const]; +"411 layer3.0.bn4.bias" [id=411, type=nncf_model_const]; +"412 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0" [id=412, type=batch_norm]; +"413 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" [id=413, type=symmetric_quantize]; +"414 layer3.0.conv5.weight" [id=414, type=nncf_model_const]; +"415 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0" [id=415, type=symmetric_quantize]; +"416 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/conv2d_0" [id=416, type=conv2d]; +"417 layer3.0.bn5.weight" [id=417, type=nncf_model_const]; +"418 layer3.0.bn5.bias" [id=418, type=nncf_model_const]; +"419 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0" [id=419, type=batch_norm]; +"420 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_2" [id=420, type=relu]; +"421 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" [id=421, type=symmetric_quantize]; +"422 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0" [id=422, type=cat]; +"423 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" [id=423, type=view]; +"424 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" [id=424, type=permute]; +"425 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" [id=425, type=reshape]; +"426 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___0" [id=426, type=__getitem__]; +"427 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___1" [id=427, type=__getitem__]; +"428 layer3.1.conv1.weight" [id=428, type=nncf_model_const]; +"429 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=429, type=symmetric_quantize]; +"430 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" [id=430, type=conv2d]; +"431 layer3.1.bn1.weight" [id=431, type=nncf_model_const]; +"432 layer3.1.bn1.bias" [id=432, type=nncf_model_const]; +"433 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" [id=433, type=batch_norm]; +"434 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_0" [id=434, type=relu]; +"435 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" [id=435, type=symmetric_quantize]; +"436 layer3.1.conv2.weight" [id=436, type=nncf_model_const]; +"437 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=437, type=symmetric_quantize]; +"438 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" [id=438, type=conv2d]; +"439 layer3.1.bn2.weight" [id=439, type=nncf_model_const]; +"440 layer3.1.bn2.bias" [id=440, type=nncf_model_const]; +"441 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" [id=441, type=batch_norm]; +"442 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=442, type=symmetric_quantize]; +"443 layer3.1.conv3.weight" [id=443, type=nncf_model_const]; +"444 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=444, type=symmetric_quantize]; +"445 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/conv2d_0" [id=445, type=conv2d]; +"446 layer3.1.bn3.weight" [id=446, type=nncf_model_const]; +"447 layer3.1.bn3.bias" [id=447, type=nncf_model_const]; +"448 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0" [id=448, type=batch_norm]; +"449 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_1" [id=449, type=relu]; +"450 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" [id=450, type=symmetric_quantize]; +"451 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0" [id=451, type=cat]; +"452 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" [id=452, type=view]; +"453 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" [id=453, type=permute]; +"454 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" [id=454, type=reshape]; +"455 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___0" [id=455, type=__getitem__]; +"456 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___1" [id=456, type=__getitem__]; +"457 layer3.2.conv1.weight" [id=457, type=nncf_model_const]; +"458 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=458, type=symmetric_quantize]; +"459 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/conv2d_0" [id=459, type=conv2d]; +"460 layer3.2.bn1.weight" [id=460, type=nncf_model_const]; +"461 layer3.2.bn1.bias" [id=461, type=nncf_model_const]; +"462 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0" [id=462, type=batch_norm]; +"463 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_0" [id=463, type=relu]; +"464 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" [id=464, type=symmetric_quantize]; +"465 layer3.2.conv2.weight" [id=465, type=nncf_model_const]; +"466 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=466, type=symmetric_quantize]; +"467 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/conv2d_0" [id=467, type=conv2d]; +"468 layer3.2.bn2.weight" [id=468, type=nncf_model_const]; +"469 layer3.2.bn2.bias" [id=469, type=nncf_model_const]; +"470 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0" [id=470, type=batch_norm]; +"471 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=471, type=symmetric_quantize]; +"472 layer3.2.conv3.weight" [id=472, type=nncf_model_const]; +"473 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=473, type=symmetric_quantize]; +"474 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/conv2d_0" [id=474, type=conv2d]; +"475 layer3.2.bn3.weight" [id=475, type=nncf_model_const]; +"476 layer3.2.bn3.bias" [id=476, type=nncf_model_const]; +"477 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0" [id=477, type=batch_norm]; +"478 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_1" [id=478, type=relu]; +"479 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" [id=479, type=symmetric_quantize]; +"480 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0" [id=480, type=cat]; +"481 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" [id=481, type=view]; +"482 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" [id=482, type=permute]; +"483 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" [id=483, type=reshape]; +"484 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___0" [id=484, type=__getitem__]; +"485 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___1" [id=485, type=__getitem__]; +"486 layer3.3.conv1.weight" [id=486, type=nncf_model_const]; +"487 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" [id=487, type=symmetric_quantize]; +"488 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/conv2d_0" [id=488, type=conv2d]; +"489 layer3.3.bn1.weight" [id=489, type=nncf_model_const]; +"490 layer3.3.bn1.bias" [id=490, type=nncf_model_const]; +"491 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0" [id=491, type=batch_norm]; +"492 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_0" [id=492, type=relu]; +"493 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" [id=493, type=symmetric_quantize]; +"494 layer3.3.conv2.weight" [id=494, type=nncf_model_const]; +"495 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=495, type=symmetric_quantize]; +"496 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/conv2d_0" [id=496, type=conv2d]; +"497 layer3.3.bn2.weight" [id=497, type=nncf_model_const]; +"498 layer3.3.bn2.bias" [id=498, type=nncf_model_const]; +"499 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0" [id=499, type=batch_norm]; +"500 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" [id=500, type=symmetric_quantize]; +"501 layer3.3.conv3.weight" [id=501, type=nncf_model_const]; +"502 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" [id=502, type=symmetric_quantize]; +"503 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/conv2d_0" [id=503, type=conv2d]; +"504 layer3.3.bn3.weight" [id=504, type=nncf_model_const]; +"505 layer3.3.bn3.bias" [id=505, type=nncf_model_const]; +"506 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0" [id=506, type=batch_norm]; +"507 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_1" [id=507, type=relu]; +"508 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" [id=508, type=symmetric_quantize]; +"509 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0" [id=509, type=cat]; +"510 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" [id=510, type=view]; +"511 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" [id=511, type=permute]; +"512 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" [id=512, type=reshape]; +"513 conv2.weight" [id=513, type=nncf_model_const]; +"514 ShuffleNetV2/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" [id=514, type=symmetric_quantize]; +"515 ShuffleNetV2/Conv2d[conv2]/conv2d_0" [id=515, type=conv2d]; +"516 bn2.weight" [id=516, type=nncf_model_const]; +"517 bn2.bias" [id=517, type=nncf_model_const]; +"518 ShuffleNetV2/BatchNorm2d[bn2]/batch_norm_0" [id=518, type=batch_norm]; +"519 ShuffleNetV2/relu_1" [id=519, type=relu]; +"520 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_1|OUTPUT]/symmetric_quantize_0" [id=520, type=symmetric_quantize]; +"521 ShuffleNetV2/avg_pool2d_0" [id=521, type=avg_pool2d]; +"522 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" [id=522, type=symmetric_quantize]; +"523 ShuffleNetV2/view_0" [id=523, type=view]; +"524 linear.weight" [id=524, type=nncf_model_const]; +"525 linear.bias" [id=525, type=nncf_model_const]; +"526 ShuffleNetV2/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" [id=526, type=symmetric_quantize]; +"527 ShuffleNetV2/Linear[linear]/linear_0" [id=527, type=linear]; +"528 /nncf_model_output_0" [id=528, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 ShuffleNetV2/NNCFConv2d[conv1]/conv2d_0"; -"2 ShuffleNetV2/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 ShuffleNetV2/NNCFConv2d[conv1]/conv2d_0"; -"3 ShuffleNetV2/NNCFConv2d[conv1]/conv2d_0" -> "4 ShuffleNetV2/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"4 ShuffleNetV2/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "5 ShuffleNetV2/relu_0"; -"5 ShuffleNetV2/relu_0" -> "6 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0"; -"6 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0" -> "8 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"6 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0" -> "17 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0"; -"7 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"8 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "9 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"9 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "10 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0"; -"10 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" -> "12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"11 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "13 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"13 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "14 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_0"; -"14 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_0" -> "15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0"; -"16 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "17 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0"; -"17 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0" -> "18 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"18 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_1"; -"19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_1" -> "20 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"20 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0"; -"21 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0"; -"22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0" -> "23 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0"; -"23 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0" -> "24 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0"; -"24 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" -> "26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0"; -"25 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0"; -"26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0" -> "27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0"; -"27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0" -> "28 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_2"; -"28 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_2" -> "29 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2"; -"29 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" -> "30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0"; -"30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0" -> "31 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/view_0"; -"31 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" -> "32 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0"; -"32 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" -> "33 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0"; -"33 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "34 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___0"; -"33 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "35 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___1"; -"34 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___0" -> "50 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0"; -"35 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___1" -> "37 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"36 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "37 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"37 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "38 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"38 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "39 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_0"; -"39 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_0" -> "40 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"40 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "42 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"41 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "42 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"42 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "43 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"43 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "44 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"44 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "46 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0"; -"45 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "46 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0"; -"46 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0" -> "47 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"47 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "48 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_1"; -"48 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_1" -> "49 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"49 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "50 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0"; -"50 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0" -> "51 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0"; -"51 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" -> "52 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0"; -"52 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" -> "53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0"; -"53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "54 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___0"; -"53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "55 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___1"; -"54 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___0" -> "70 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0"; -"55 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___1" -> "57 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0"; -"56 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0"; -"57 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0" -> "58 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"58 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "59 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_0"; -"59 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_0" -> "60 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0"; -"60 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" -> "62 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0"; -"61 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0"; -"62 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0" -> "63 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"63 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "64 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"64 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "66 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0"; -"65 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0"; -"66 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0" -> "67 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"67 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "68 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_1"; -"68 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_1" -> "69 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1"; -"69 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" -> "70 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0"; -"70 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0" -> "71 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0"; -"71 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" -> "72 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0"; -"72 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" -> "73 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0"; -"73 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "74 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___0"; -"73 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "75 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___1"; -"74 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___0" -> "90 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0"; -"75 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___1" -> "77 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0"; -"76 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "77 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0"; -"77 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0" -> "78 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"78 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "79 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_0"; -"79 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_0" -> "80 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0"; -"80 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" -> "82 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0"; -"81 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0"; -"82 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0" -> "83 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"83 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "84 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"84 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "86 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0"; -"85 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "86 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0"; -"86 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0" -> "87 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"87 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "88 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_1"; -"88 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_1" -> "89 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1"; -"89 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" -> "90 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0"; -"90 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0" -> "91 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0"; -"91 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" -> "92 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0"; -"92 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" -> "93 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0"; -"93 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "95 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"93 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "104 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0"; -"94 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "95 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"95 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "96 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"96 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "97 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0"; -"97 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" -> "99 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"98 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "99 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"99 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "100 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"100 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "101 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_0"; -"101 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_0" -> "102 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"102 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "117 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0"; -"103 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "104 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0"; -"104 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0" -> "105 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"105 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "106 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_1"; -"106 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_1" -> "107 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"107 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "109 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0"; -"108 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "109 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0"; -"109 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0" -> "110 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0"; -"110 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0" -> "111 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0"; -"111 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" -> "113 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0"; -"112 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "113 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0"; -"113 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0" -> "114 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0"; -"114 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0" -> "115 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_2"; -"115 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_2" -> "116 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2"; -"116 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" -> "117 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0"; -"117 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0" -> "118 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/view_0"; -"118 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" -> "119 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0"; -"119 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" -> "120 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0"; -"120 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "121 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___0"; -"120 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "122 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___1"; -"121 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___0" -> "137 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0"; -"122 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___1" -> "124 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"123 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "124 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"124 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "125 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"125 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "126 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_0"; -"126 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_0" -> "127 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"127 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "129 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"128 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "129 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"129 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "130 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"130 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "131 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"131 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "133 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0"; -"132 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "133 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0"; -"133 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0" -> "134 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"134 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "135 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_1"; -"135 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_1" -> "136 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"136 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "137 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0"; -"137 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0" -> "138 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0"; -"138 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" -> "139 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0"; -"139 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" -> "140 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0"; -"140 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "141 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___0"; -"140 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "142 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___1"; -"141 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___0" -> "157 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0"; -"142 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___1" -> "144 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0"; -"143 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "144 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0"; -"144 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0" -> "145 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"145 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "146 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_0"; -"146 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_0" -> "147 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0"; -"147 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" -> "149 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0"; -"148 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0"; -"149 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0" -> "150 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"150 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "151 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"151 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "153 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0"; -"152 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "153 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0"; -"153 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0" -> "154 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"154 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "155 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_1"; -"155 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_1" -> "156 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1"; -"156 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" -> "157 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0"; -"157 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0" -> "158 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0"; -"158 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" -> "159 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0"; -"159 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" -> "160 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0"; -"160 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "161 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___0"; -"160 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "162 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___1"; -"161 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___0" -> "177 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0"; -"162 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___1" -> "164 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0"; -"163 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "164 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0"; -"164 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0" -> "165 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"165 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "166 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_0"; -"166 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_0" -> "167 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0"; -"167 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" -> "169 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0"; -"168 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "169 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0"; -"169 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0" -> "170 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"170 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "171 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"171 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "173 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0"; -"172 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "173 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0"; -"173 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0" -> "174 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"174 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "175 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_1"; -"175 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_1" -> "176 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1"; -"176 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" -> "177 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0"; -"177 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0" -> "178 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0"; -"178 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" -> "179 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0"; -"179 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" -> "180 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0"; -"180 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "181 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___0"; -"180 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "182 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___1"; -"181 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___0" -> "197 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0"; -"182 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___1" -> "184 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv1]/conv2d_0"; -"183 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "184 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv1]/conv2d_0"; -"184 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv1]/conv2d_0" -> "185 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"185 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "186 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_0"; -"186 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_0" -> "187 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_0"; -"187 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_0" -> "189 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv2]/conv2d_0"; -"188 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "189 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv2]/conv2d_0"; -"189 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv2]/conv2d_0" -> "190 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"190 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "191 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"191 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "193 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv3]/conv2d_0"; -"192 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "193 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv3]/conv2d_0"; -"193 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFConv2d[conv3]/conv2d_0" -> "194 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"194 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "195 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_1"; -"195 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_1" -> "196 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_1"; -"196 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_1" -> "197 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0"; -"197 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0" -> "198 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/view_0"; -"198 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/view_0" -> "199 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/permute_0"; -"199 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/permute_0" -> "200 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0"; -"200 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0" -> "201 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___0"; -"200 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0" -> "202 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___1"; -"201 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___0" -> "217 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0"; -"202 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___1" -> "204 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv1]/conv2d_0"; -"203 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "204 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv1]/conv2d_0"; -"204 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv1]/conv2d_0" -> "205 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"205 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "206 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_0"; -"206 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_0" -> "207 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_0"; -"207 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_0" -> "209 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv2]/conv2d_0"; -"208 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "209 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv2]/conv2d_0"; -"209 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv2]/conv2d_0" -> "210 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"210 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "211 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"211 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "213 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv3]/conv2d_0"; -"212 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "213 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv3]/conv2d_0"; -"213 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFConv2d[conv3]/conv2d_0" -> "214 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"214 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "215 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_1"; -"215 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_1" -> "216 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_1"; -"216 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_1" -> "217 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0"; -"217 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0" -> "218 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/view_0"; -"218 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/view_0" -> "219 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/permute_0"; -"219 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/permute_0" -> "220 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0"; -"220 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0" -> "221 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___0"; -"220 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0" -> "222 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___1"; -"221 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___0" -> "237 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0"; -"222 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___1" -> "224 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv1]/conv2d_0"; -"223 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "224 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv1]/conv2d_0"; -"224 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv1]/conv2d_0" -> "225 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"225 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "226 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_0"; -"226 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_0" -> "227 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_0"; -"227 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_0" -> "229 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv2]/conv2d_0"; -"228 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "229 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv2]/conv2d_0"; -"229 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv2]/conv2d_0" -> "230 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"230 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "231 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"231 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "233 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv3]/conv2d_0"; -"232 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "233 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv3]/conv2d_0"; -"233 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFConv2d[conv3]/conv2d_0" -> "234 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"234 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "235 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_1"; -"235 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_1" -> "236 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_1"; -"236 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_1" -> "237 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0"; -"237 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0" -> "238 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/view_0"; -"238 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/view_0" -> "239 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/permute_0"; -"239 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/permute_0" -> "240 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0"; -"240 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0" -> "241 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___0"; -"240 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0" -> "242 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___1"; -"241 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___0" -> "257 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0"; -"242 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___1" -> "244 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv1]/conv2d_0"; -"243 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "244 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv1]/conv2d_0"; -"244 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv1]/conv2d_0" -> "245 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"245 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "246 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_0"; -"246 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_0" -> "247 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_0"; -"247 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_0" -> "249 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv2]/conv2d_0"; -"248 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "249 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv2]/conv2d_0"; -"249 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv2]/conv2d_0" -> "250 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"250 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "251 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"251 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "253 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv3]/conv2d_0"; -"252 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "253 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv3]/conv2d_0"; -"253 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFConv2d[conv3]/conv2d_0" -> "254 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"254 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "255 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_1"; -"255 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_1" -> "256 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_1"; -"256 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_1" -> "257 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0"; -"257 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0" -> "258 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/view_0"; -"258 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/view_0" -> "259 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/permute_0"; -"259 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/permute_0" -> "260 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0"; -"260 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0" -> "262 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"260 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0" -> "271 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0"; -"261 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "262 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0"; -"262 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv1]/conv2d_0" -> "263 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"263 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "264 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0"; -"264 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" -> "266 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"265 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "266 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0"; -"266 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv2]/conv2d_0" -> "267 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"267 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "268 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_0"; -"268 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_0" -> "269 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; -"269 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "284 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0"; -"270 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "271 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0"; -"271 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv3]/conv2d_0" -> "272 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"272 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "273 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_1"; -"273 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_1" -> "274 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; -"274 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "276 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0"; -"275 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "276 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0"; -"276 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv4]/conv2d_0" -> "277 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0"; -"277 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn4]/batch_norm_0" -> "278 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0"; -"278 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" -> "280 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0"; -"279 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "280 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0"; -"280 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFConv2d[conv5]/conv2d_0" -> "281 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0"; -"281 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/NNCFBatchNorm2d[bn5]/batch_norm_0" -> "282 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_2"; -"282 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_2" -> "283 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2"; -"283 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" -> "284 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0"; -"284 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0" -> "285 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/view_0"; -"285 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" -> "286 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0"; -"286 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" -> "287 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0"; -"287 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "288 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___0"; -"287 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "289 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___1"; -"288 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___0" -> "304 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0"; -"289 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___1" -> "291 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"290 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "291 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0"; -"291 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv1]/conv2d_0" -> "292 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"292 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "293 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_0"; -"293 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_0" -> "294 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; -"294 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "296 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"295 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "296 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0"; -"296 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv2]/conv2d_0" -> "297 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"297 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "298 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"298 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "300 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0"; -"299 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "300 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0"; -"300 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFConv2d[conv3]/conv2d_0" -> "301 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"301 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "302 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_1"; -"302 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_1" -> "303 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; -"303 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "304 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0"; -"304 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0" -> "305 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0"; -"305 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" -> "306 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0"; -"306 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" -> "307 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0"; -"307 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "308 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___0"; -"307 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "309 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___1"; -"308 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___0" -> "324 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0"; -"309 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___1" -> "311 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0"; -"310 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "311 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0"; -"311 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv1]/conv2d_0" -> "312 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"312 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "313 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_0"; -"313 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_0" -> "314 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0"; -"314 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" -> "316 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0"; -"315 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "316 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0"; -"316 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv2]/conv2d_0" -> "317 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"317 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "318 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"318 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "320 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0"; -"319 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "320 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0"; -"320 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFConv2d[conv3]/conv2d_0" -> "321 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"321 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "322 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_1"; -"322 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_1" -> "323 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1"; -"323 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" -> "324 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0"; -"324 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0" -> "325 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0"; -"325 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" -> "326 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0"; -"326 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" -> "327 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0"; -"327 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "328 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___0"; -"327 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "329 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___1"; -"328 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___0" -> "344 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0"; -"329 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___1" -> "331 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0"; -"330 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "331 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0"; -"331 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv1]/conv2d_0" -> "332 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; -"332 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "333 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_0"; -"333 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_0" -> "334 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0"; -"334 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" -> "336 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0"; -"335 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "336 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0"; -"336 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv2]/conv2d_0" -> "337 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"337 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "338 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; -"338 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "340 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0"; -"339 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "340 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0"; -"340 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFConv2d[conv3]/conv2d_0" -> "341 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; -"341 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "342 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_1"; -"342 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_1" -> "343 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1"; -"343 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" -> "344 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0"; -"344 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0" -> "345 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0"; -"345 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" -> "346 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0"; -"346 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" -> "347 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0"; -"347 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "349 ShuffleNetV2/NNCFConv2d[conv2]/conv2d_0"; -"348 ShuffleNetV2/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "349 ShuffleNetV2/NNCFConv2d[conv2]/conv2d_0"; -"349 ShuffleNetV2/NNCFConv2d[conv2]/conv2d_0" -> "350 ShuffleNetV2/NNCFBatchNorm2d[bn2]/batch_norm_0"; -"350 ShuffleNetV2/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "351 ShuffleNetV2/relu_1"; -"351 ShuffleNetV2/relu_1" -> "352 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_1|OUTPUT]/symmetric_quantize_0"; -"352 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_1|OUTPUT]/symmetric_quantize_0" -> "353 ShuffleNetV2/avg_pool2d_0"; -"353 ShuffleNetV2/avg_pool2d_0" -> "354 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; -"354 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "355 ShuffleNetV2/view_0"; -"355 ShuffleNetV2/view_0" -> "357 ShuffleNetV2/NNCFLinear[linear]/linear_0"; -"356 ShuffleNetV2/NNCFLinear[linear]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "357 ShuffleNetV2/NNCFLinear[linear]/linear_0"; -"357 ShuffleNetV2/NNCFLinear[linear]/linear_0" -> "358 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "4 ShuffleNetV2/Conv2d[conv1]/conv2d_0"; +"2 conv1.weight" -> "3 ShuffleNetV2/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"3 ShuffleNetV2/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "4 ShuffleNetV2/Conv2d[conv1]/conv2d_0"; +"4 ShuffleNetV2/Conv2d[conv1]/conv2d_0" -> "7 ShuffleNetV2/BatchNorm2d[bn1]/batch_norm_0"; +"5 bn1.weight" -> "7 ShuffleNetV2/BatchNorm2d[bn1]/batch_norm_0"; +"6 bn1.bias" -> "7 ShuffleNetV2/BatchNorm2d[bn1]/batch_norm_0"; +"7 ShuffleNetV2/BatchNorm2d[bn1]/batch_norm_0" -> "8 ShuffleNetV2/relu_0"; +"8 ShuffleNetV2/relu_0" -> "9 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0"; +"9 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0" -> "12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/conv2d_0"; +"9 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_0|OUTPUT]/symmetric_quantize_0" -> "27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/conv2d_0"; +"10 layer1.0.conv1.weight" -> "11 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"11 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/conv2d_0"; +"12 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv1]/conv2d_0" -> "15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"13 layer1.0.bn1.weight" -> "15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"14 layer1.0.bn1.bias" -> "15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"15 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "16 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0"; +"16 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" -> "19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/conv2d_0"; +"17 layer1.0.conv2.weight" -> "18 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"18 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/conv2d_0"; +"19 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv2]/conv2d_0" -> "22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"20 layer1.0.bn2.weight" -> "22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"21 layer1.0.bn2.bias" -> "22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"22 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "23 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_0"; +"23 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_0" -> "24 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"24 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "48 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0"; +"25 layer1.0.conv3.weight" -> "26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"26 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/conv2d_0"; +"27 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv3]/conv2d_0" -> "30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"28 layer1.0.bn3.weight" -> "30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"29 layer1.0.bn3.bias" -> "30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"30 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0" -> "31 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_1"; +"31 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_1" -> "32 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"32 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "35 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/conv2d_0"; +"33 layer1.0.conv4.weight" -> "34 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0"; +"34 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0" -> "35 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/conv2d_0"; +"35 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv4]/conv2d_0" -> "38 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"36 layer1.0.bn4.weight" -> "38 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"37 layer1.0.bn4.bias" -> "38 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"38 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0" -> "39 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0"; +"39 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" -> "42 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/conv2d_0"; +"40 layer1.0.conv5.weight" -> "41 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0"; +"41 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0" -> "42 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/conv2d_0"; +"42 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/Conv2d[conv5]/conv2d_0" -> "45 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"43 layer1.0.bn5.weight" -> "45 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"44 layer1.0.bn5.bias" -> "45 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"45 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0" -> "46 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_2"; +"46 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/relu_2" -> "47 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2"; +"47 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" -> "48 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0"; +"48 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/cat_0" -> "49 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/view_0"; +"49 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" -> "50 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0"; +"50 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" -> "51 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0"; +"51 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "52 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___0"; +"51 ShuffleNetV2/Sequential[layer1]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___1"; +"52 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___0" -> "77 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0"; +"53 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SplitBlock[split]/__getitem___1" -> "56 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"54 layer1.1.conv1.weight" -> "55 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"55 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "56 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"56 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "59 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"57 layer1.1.bn1.weight" -> "59 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"58 layer1.1.bn1.bias" -> "59 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"59 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "60 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_0"; +"60 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_0" -> "61 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"61 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "64 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"62 layer1.1.conv2.weight" -> "63 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"63 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "64 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"64 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "67 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"65 layer1.1.bn2.weight" -> "67 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"66 layer1.1.bn2.bias" -> "67 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"67 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "68 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"68 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "71 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/conv2d_0"; +"69 layer1.1.conv3.weight" -> "70 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"70 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "71 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/conv2d_0"; +"71 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/Conv2d[conv3]/conv2d_0" -> "74 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"72 layer1.1.bn3.weight" -> "74 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"73 layer1.1.bn3.bias" -> "74 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"74 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0" -> "75 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_1"; +"75 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/relu_1" -> "76 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"76 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "77 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0"; +"77 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/cat_0" -> "78 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0"; +"78 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" -> "79 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0"; +"79 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" -> "80 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0"; +"80 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "81 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___0"; +"80 ShuffleNetV2/Sequential[layer1]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "82 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___1"; +"81 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___0" -> "106 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0"; +"82 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SplitBlock[split]/__getitem___1" -> "85 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/conv2d_0"; +"83 layer1.2.conv1.weight" -> "84 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"84 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "85 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/conv2d_0"; +"85 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv1]/conv2d_0" -> "88 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"86 layer1.2.bn1.weight" -> "88 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"87 layer1.2.bn1.bias" -> "88 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"88 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0" -> "89 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_0"; +"89 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_0" -> "90 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0"; +"90 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" -> "93 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/conv2d_0"; +"91 layer1.2.conv2.weight" -> "92 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"92 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "93 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/conv2d_0"; +"93 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv2]/conv2d_0" -> "96 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"94 layer1.2.bn2.weight" -> "96 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"95 layer1.2.bn2.bias" -> "96 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"96 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0" -> "97 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"97 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "100 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/conv2d_0"; +"98 layer1.2.conv3.weight" -> "99 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"99 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "100 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/conv2d_0"; +"100 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/Conv2d[conv3]/conv2d_0" -> "103 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"101 layer1.2.bn3.weight" -> "103 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"102 layer1.2.bn3.bias" -> "103 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"103 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0" -> "104 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_1"; +"104 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/relu_1" -> "105 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1"; +"105 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" -> "106 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0"; +"106 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/cat_0" -> "107 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0"; +"107 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" -> "108 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0"; +"108 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" -> "109 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0"; +"109 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "110 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___0"; +"109 ShuffleNetV2/Sequential[layer1]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "111 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___1"; +"110 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___0" -> "135 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0"; +"111 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SplitBlock[split]/__getitem___1" -> "114 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/conv2d_0"; +"112 layer1.3.conv1.weight" -> "113 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"113 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "114 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/conv2d_0"; +"114 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv1]/conv2d_0" -> "117 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"115 layer1.3.bn1.weight" -> "117 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"116 layer1.3.bn1.bias" -> "117 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"117 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0" -> "118 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_0"; +"118 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_0" -> "119 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0"; +"119 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" -> "122 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/conv2d_0"; +"120 layer1.3.conv2.weight" -> "121 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"121 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "122 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/conv2d_0"; +"122 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv2]/conv2d_0" -> "125 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"123 layer1.3.bn2.weight" -> "125 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"124 layer1.3.bn2.bias" -> "125 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"125 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0" -> "126 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"126 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "129 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/conv2d_0"; +"127 layer1.3.conv3.weight" -> "128 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"128 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "129 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/conv2d_0"; +"129 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/Conv2d[conv3]/conv2d_0" -> "132 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"130 layer1.3.bn3.weight" -> "132 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"131 layer1.3.bn3.bias" -> "132 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"132 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0" -> "133 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_1"; +"133 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/relu_1" -> "134 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1"; +"134 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" -> "135 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0"; +"135 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/cat_0" -> "136 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0"; +"136 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" -> "137 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0"; +"137 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" -> "138 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0"; +"138 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "141 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/conv2d_0"; +"138 ShuffleNetV2/Sequential[layer1]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "156 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/conv2d_0"; +"139 layer2.0.conv1.weight" -> "140 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"140 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "141 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/conv2d_0"; +"141 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv1]/conv2d_0" -> "144 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"142 layer2.0.bn1.weight" -> "144 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"143 layer2.0.bn1.bias" -> "144 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"144 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "145 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0"; +"145 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" -> "148 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/conv2d_0"; +"146 layer2.0.conv2.weight" -> "147 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"147 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "148 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/conv2d_0"; +"148 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv2]/conv2d_0" -> "151 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"149 layer2.0.bn2.weight" -> "151 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"150 layer2.0.bn2.bias" -> "151 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"151 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "152 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_0"; +"152 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_0" -> "153 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"153 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "177 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0"; +"154 layer2.0.conv3.weight" -> "155 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"155 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "156 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/conv2d_0"; +"156 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv3]/conv2d_0" -> "159 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"157 layer2.0.bn3.weight" -> "159 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"158 layer2.0.bn3.bias" -> "159 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"159 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0" -> "160 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_1"; +"160 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_1" -> "161 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"161 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "164 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/conv2d_0"; +"162 layer2.0.conv4.weight" -> "163 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0"; +"163 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0" -> "164 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/conv2d_0"; +"164 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv4]/conv2d_0" -> "167 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"165 layer2.0.bn4.weight" -> "167 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"166 layer2.0.bn4.bias" -> "167 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"167 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0" -> "168 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0"; +"168 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" -> "171 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/conv2d_0"; +"169 layer2.0.conv5.weight" -> "170 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0"; +"170 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0" -> "171 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/conv2d_0"; +"171 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/Conv2d[conv5]/conv2d_0" -> "174 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"172 layer2.0.bn5.weight" -> "174 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"173 layer2.0.bn5.bias" -> "174 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"174 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0" -> "175 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_2"; +"175 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/relu_2" -> "176 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2"; +"176 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" -> "177 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0"; +"177 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/cat_0" -> "178 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/view_0"; +"178 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" -> "179 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0"; +"179 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" -> "180 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0"; +"180 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "181 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___0"; +"180 ShuffleNetV2/Sequential[layer2]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "182 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___1"; +"181 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___0" -> "206 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0"; +"182 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SplitBlock[split]/__getitem___1" -> "185 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"183 layer2.1.conv1.weight" -> "184 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"184 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "185 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"185 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "188 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"186 layer2.1.bn1.weight" -> "188 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"187 layer2.1.bn1.bias" -> "188 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"188 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "189 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_0"; +"189 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_0" -> "190 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"190 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "193 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"191 layer2.1.conv2.weight" -> "192 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"192 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "193 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"193 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "196 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"194 layer2.1.bn2.weight" -> "196 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"195 layer2.1.bn2.bias" -> "196 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"196 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "197 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"197 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "200 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/conv2d_0"; +"198 layer2.1.conv3.weight" -> "199 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"199 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "200 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/conv2d_0"; +"200 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/Conv2d[conv3]/conv2d_0" -> "203 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"201 layer2.1.bn3.weight" -> "203 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"202 layer2.1.bn3.bias" -> "203 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"203 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0" -> "204 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_1"; +"204 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/relu_1" -> "205 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"205 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "206 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0"; +"206 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/cat_0" -> "207 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0"; +"207 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" -> "208 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0"; +"208 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" -> "209 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0"; +"209 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "210 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___0"; +"209 ShuffleNetV2/Sequential[layer2]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "211 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___1"; +"210 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___0" -> "235 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0"; +"211 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SplitBlock[split]/__getitem___1" -> "214 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/conv2d_0"; +"212 layer2.2.conv1.weight" -> "213 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"213 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "214 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/conv2d_0"; +"214 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv1]/conv2d_0" -> "217 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"215 layer2.2.bn1.weight" -> "217 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"216 layer2.2.bn1.bias" -> "217 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"217 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0" -> "218 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_0"; +"218 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_0" -> "219 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0"; +"219 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" -> "222 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/conv2d_0"; +"220 layer2.2.conv2.weight" -> "221 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"221 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "222 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/conv2d_0"; +"222 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv2]/conv2d_0" -> "225 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"223 layer2.2.bn2.weight" -> "225 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"224 layer2.2.bn2.bias" -> "225 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"225 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0" -> "226 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"226 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "229 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/conv2d_0"; +"227 layer2.2.conv3.weight" -> "228 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"228 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "229 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/conv2d_0"; +"229 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/Conv2d[conv3]/conv2d_0" -> "232 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"230 layer2.2.bn3.weight" -> "232 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"231 layer2.2.bn3.bias" -> "232 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"232 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0" -> "233 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_1"; +"233 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/relu_1" -> "234 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1"; +"234 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" -> "235 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0"; +"235 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/cat_0" -> "236 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0"; +"236 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" -> "237 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0"; +"237 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" -> "238 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0"; +"238 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "239 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___0"; +"238 ShuffleNetV2/Sequential[layer2]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "240 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___1"; +"239 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___0" -> "264 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0"; +"240 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SplitBlock[split]/__getitem___1" -> "243 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/conv2d_0"; +"241 layer2.3.conv1.weight" -> "242 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"242 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "243 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/conv2d_0"; +"243 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv1]/conv2d_0" -> "246 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"244 layer2.3.bn1.weight" -> "246 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"245 layer2.3.bn1.bias" -> "246 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"246 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0" -> "247 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_0"; +"247 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_0" -> "248 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0"; +"248 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" -> "251 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/conv2d_0"; +"249 layer2.3.conv2.weight" -> "250 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"250 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "251 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/conv2d_0"; +"251 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv2]/conv2d_0" -> "254 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"252 layer2.3.bn2.weight" -> "254 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"253 layer2.3.bn2.bias" -> "254 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"254 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0" -> "255 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"255 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "258 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/conv2d_0"; +"256 layer2.3.conv3.weight" -> "257 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"257 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "258 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/conv2d_0"; +"258 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/Conv2d[conv3]/conv2d_0" -> "261 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"259 layer2.3.bn3.weight" -> "261 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"260 layer2.3.bn3.bias" -> "261 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"261 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0" -> "262 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_1"; +"262 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/relu_1" -> "263 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1"; +"263 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" -> "264 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0"; +"264 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/cat_0" -> "265 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0"; +"265 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" -> "266 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0"; +"266 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" -> "267 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0"; +"267 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "268 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___0"; +"267 ShuffleNetV2/Sequential[layer2]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "269 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___1"; +"268 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___0" -> "293 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0"; +"269 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SplitBlock[split]/__getitem___1" -> "272 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/conv2d_0"; +"270 layer2.4.conv1.weight" -> "271 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"271 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "272 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/conv2d_0"; +"272 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv1]/conv2d_0" -> "275 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn1]/batch_norm_0"; +"273 layer2.4.bn1.weight" -> "275 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn1]/batch_norm_0"; +"274 layer2.4.bn1.bias" -> "275 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn1]/batch_norm_0"; +"275 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn1]/batch_norm_0" -> "276 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_0"; +"276 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_0" -> "277 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_0"; +"277 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_0" -> "280 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/conv2d_0"; +"278 layer2.4.conv2.weight" -> "279 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"279 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "280 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/conv2d_0"; +"280 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv2]/conv2d_0" -> "283 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/batch_norm_0"; +"281 layer2.4.bn2.weight" -> "283 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/batch_norm_0"; +"282 layer2.4.bn2.bias" -> "283 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/batch_norm_0"; +"283 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/batch_norm_0" -> "284 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"284 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "287 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/conv2d_0"; +"285 layer2.4.conv3.weight" -> "286 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"286 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "287 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/conv2d_0"; +"287 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/Conv2d[conv3]/conv2d_0" -> "290 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn3]/batch_norm_0"; +"288 layer2.4.bn3.weight" -> "290 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn3]/batch_norm_0"; +"289 layer2.4.bn3.bias" -> "290 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn3]/batch_norm_0"; +"290 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/BatchNorm2d[bn3]/batch_norm_0" -> "291 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_1"; +"291 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/relu_1" -> "292 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_1"; +"292 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/SymmetricQuantizer/symmetric_quantize_1" -> "293 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0"; +"293 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/cat_0" -> "294 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/view_0"; +"294 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/view_0" -> "295 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/permute_0"; +"295 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/permute_0" -> "296 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0"; +"296 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0" -> "297 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___0"; +"296 ShuffleNetV2/Sequential[layer2]/BasicBlock[4]/ShuffleBlock[shuffle]/reshape_0" -> "298 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___1"; +"297 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___0" -> "322 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0"; +"298 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SplitBlock[split]/__getitem___1" -> "301 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/conv2d_0"; +"299 layer2.5.conv1.weight" -> "300 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"300 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "301 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/conv2d_0"; +"301 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv1]/conv2d_0" -> "304 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn1]/batch_norm_0"; +"302 layer2.5.bn1.weight" -> "304 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn1]/batch_norm_0"; +"303 layer2.5.bn1.bias" -> "304 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn1]/batch_norm_0"; +"304 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn1]/batch_norm_0" -> "305 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_0"; +"305 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_0" -> "306 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_0"; +"306 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_0" -> "309 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/conv2d_0"; +"307 layer2.5.conv2.weight" -> "308 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"308 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "309 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/conv2d_0"; +"309 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv2]/conv2d_0" -> "312 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/batch_norm_0"; +"310 layer2.5.bn2.weight" -> "312 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/batch_norm_0"; +"311 layer2.5.bn2.bias" -> "312 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/batch_norm_0"; +"312 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/batch_norm_0" -> "313 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"313 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "316 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/conv2d_0"; +"314 layer2.5.conv3.weight" -> "315 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"315 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "316 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/conv2d_0"; +"316 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/Conv2d[conv3]/conv2d_0" -> "319 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn3]/batch_norm_0"; +"317 layer2.5.bn3.weight" -> "319 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn3]/batch_norm_0"; +"318 layer2.5.bn3.bias" -> "319 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn3]/batch_norm_0"; +"319 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/BatchNorm2d[bn3]/batch_norm_0" -> "320 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_1"; +"320 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/relu_1" -> "321 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_1"; +"321 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/SymmetricQuantizer/symmetric_quantize_1" -> "322 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0"; +"322 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/cat_0" -> "323 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/view_0"; +"323 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/view_0" -> "324 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/permute_0"; +"324 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/permute_0" -> "325 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0"; +"325 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0" -> "326 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___0"; +"325 ShuffleNetV2/Sequential[layer2]/BasicBlock[5]/ShuffleBlock[shuffle]/reshape_0" -> "327 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___1"; +"326 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___0" -> "351 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0"; +"327 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SplitBlock[split]/__getitem___1" -> "330 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/conv2d_0"; +"328 layer2.6.conv1.weight" -> "329 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"329 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "330 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/conv2d_0"; +"330 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv1]/conv2d_0" -> "333 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn1]/batch_norm_0"; +"331 layer2.6.bn1.weight" -> "333 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn1]/batch_norm_0"; +"332 layer2.6.bn1.bias" -> "333 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn1]/batch_norm_0"; +"333 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn1]/batch_norm_0" -> "334 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_0"; +"334 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_0" -> "335 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_0"; +"335 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_0" -> "338 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/conv2d_0"; +"336 layer2.6.conv2.weight" -> "337 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"337 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "338 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/conv2d_0"; +"338 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv2]/conv2d_0" -> "341 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/batch_norm_0"; +"339 layer2.6.bn2.weight" -> "341 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/batch_norm_0"; +"340 layer2.6.bn2.bias" -> "341 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/batch_norm_0"; +"341 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/batch_norm_0" -> "342 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"342 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "345 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/conv2d_0"; +"343 layer2.6.conv3.weight" -> "344 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"344 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "345 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/conv2d_0"; +"345 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/Conv2d[conv3]/conv2d_0" -> "348 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn3]/batch_norm_0"; +"346 layer2.6.bn3.weight" -> "348 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn3]/batch_norm_0"; +"347 layer2.6.bn3.bias" -> "348 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn3]/batch_norm_0"; +"348 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/BatchNorm2d[bn3]/batch_norm_0" -> "349 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_1"; +"349 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/relu_1" -> "350 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_1"; +"350 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/SymmetricQuantizer/symmetric_quantize_1" -> "351 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0"; +"351 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/cat_0" -> "352 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/view_0"; +"352 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/view_0" -> "353 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/permute_0"; +"353 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/permute_0" -> "354 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0"; +"354 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0" -> "355 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___0"; +"354 ShuffleNetV2/Sequential[layer2]/BasicBlock[6]/ShuffleBlock[shuffle]/reshape_0" -> "356 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___1"; +"355 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___0" -> "380 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0"; +"356 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SplitBlock[split]/__getitem___1" -> "359 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/conv2d_0"; +"357 layer2.7.conv1.weight" -> "358 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"358 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "359 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/conv2d_0"; +"359 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv1]/conv2d_0" -> "362 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn1]/batch_norm_0"; +"360 layer2.7.bn1.weight" -> "362 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn1]/batch_norm_0"; +"361 layer2.7.bn1.bias" -> "362 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn1]/batch_norm_0"; +"362 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn1]/batch_norm_0" -> "363 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_0"; +"363 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_0" -> "364 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_0"; +"364 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_0" -> "367 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/conv2d_0"; +"365 layer2.7.conv2.weight" -> "366 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"366 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "367 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/conv2d_0"; +"367 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv2]/conv2d_0" -> "370 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/batch_norm_0"; +"368 layer2.7.bn2.weight" -> "370 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/batch_norm_0"; +"369 layer2.7.bn2.bias" -> "370 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/batch_norm_0"; +"370 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/batch_norm_0" -> "371 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"371 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "374 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/conv2d_0"; +"372 layer2.7.conv3.weight" -> "373 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"373 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "374 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/conv2d_0"; +"374 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/Conv2d[conv3]/conv2d_0" -> "377 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn3]/batch_norm_0"; +"375 layer2.7.bn3.weight" -> "377 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn3]/batch_norm_0"; +"376 layer2.7.bn3.bias" -> "377 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn3]/batch_norm_0"; +"377 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/BatchNorm2d[bn3]/batch_norm_0" -> "378 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_1"; +"378 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/relu_1" -> "379 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_1"; +"379 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/SymmetricQuantizer/symmetric_quantize_1" -> "380 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0"; +"380 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/cat_0" -> "381 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/view_0"; +"381 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/view_0" -> "382 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/permute_0"; +"382 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/permute_0" -> "383 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0"; +"383 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0" -> "386 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/conv2d_0"; +"383 ShuffleNetV2/Sequential[layer2]/BasicBlock[7]/ShuffleBlock[shuffle]/reshape_0" -> "401 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/conv2d_0"; +"384 layer3.0.conv1.weight" -> "385 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"385 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "386 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/conv2d_0"; +"386 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv1]/conv2d_0" -> "389 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"387 layer3.0.bn1.weight" -> "389 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"388 layer3.0.bn1.bias" -> "389 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0"; +"389 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/batch_norm_0" -> "390 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0"; +"390 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn1]/SymmetricQuantizer/symmetric_quantize_0" -> "393 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/conv2d_0"; +"391 layer3.0.conv2.weight" -> "392 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"392 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "393 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/conv2d_0"; +"393 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv2]/conv2d_0" -> "396 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"394 layer3.0.bn2.weight" -> "396 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"395 layer3.0.bn2.bias" -> "396 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0"; +"396 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn2]/batch_norm_0" -> "397 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_0"; +"397 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_0" -> "398 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0"; +"398 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_0" -> "422 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0"; +"399 layer3.0.conv3.weight" -> "400 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"400 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "401 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/conv2d_0"; +"401 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv3]/conv2d_0" -> "404 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"402 layer3.0.bn3.weight" -> "404 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"403 layer3.0.bn3.bias" -> "404 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0"; +"404 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn3]/batch_norm_0" -> "405 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_1"; +"405 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_1" -> "406 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1"; +"406 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_1" -> "409 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/conv2d_0"; +"407 layer3.0.conv4.weight" -> "408 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0"; +"408 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/SymmetricQuantizer/symmetric_quantize_0" -> "409 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/conv2d_0"; +"409 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv4]/conv2d_0" -> "412 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"410 layer3.0.bn4.weight" -> "412 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"411 layer3.0.bn4.bias" -> "412 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0"; +"412 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/batch_norm_0" -> "413 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0"; +"413 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn4]/SymmetricQuantizer/symmetric_quantize_0" -> "416 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/conv2d_0"; +"414 layer3.0.conv5.weight" -> "415 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0"; +"415 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/SymmetricQuantizer/symmetric_quantize_0" -> "416 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/conv2d_0"; +"416 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/Conv2d[conv5]/conv2d_0" -> "419 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"417 layer3.0.bn5.weight" -> "419 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"418 layer3.0.bn5.bias" -> "419 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0"; +"419 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/BatchNorm2d[bn5]/batch_norm_0" -> "420 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_2"; +"420 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/relu_2" -> "421 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2"; +"421 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/SymmetricQuantizer/symmetric_quantize_2" -> "422 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0"; +"422 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/cat_0" -> "423 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/view_0"; +"423 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/view_0" -> "424 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0"; +"424 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/permute_0" -> "425 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0"; +"425 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "426 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___0"; +"425 ShuffleNetV2/Sequential[layer3]/DownBlock[0]/ShuffleBlock[shuffle]/reshape_0" -> "427 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___1"; +"426 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___0" -> "451 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0"; +"427 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SplitBlock[split]/__getitem___1" -> "430 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"428 layer3.1.conv1.weight" -> "429 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"429 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "430 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0"; +"430 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv1]/conv2d_0" -> "433 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"431 layer3.1.bn1.weight" -> "433 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"432 layer3.1.bn1.bias" -> "433 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0"; +"433 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn1]/batch_norm_0" -> "434 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_0"; +"434 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_0" -> "435 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0"; +"435 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_0" -> "438 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"436 layer3.1.conv2.weight" -> "437 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"437 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "438 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0"; +"438 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv2]/conv2d_0" -> "441 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"439 layer3.1.bn2.weight" -> "441 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"440 layer3.1.bn2.bias" -> "441 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0"; +"441 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/batch_norm_0" -> "442 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"442 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "445 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/conv2d_0"; +"443 layer3.1.conv3.weight" -> "444 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"444 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "445 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/conv2d_0"; +"445 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/Conv2d[conv3]/conv2d_0" -> "448 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"446 layer3.1.bn3.weight" -> "448 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"447 layer3.1.bn3.bias" -> "448 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0"; +"448 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/BatchNorm2d[bn3]/batch_norm_0" -> "449 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_1"; +"449 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/relu_1" -> "450 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1"; +"450 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/SymmetricQuantizer/symmetric_quantize_1" -> "451 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0"; +"451 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/cat_0" -> "452 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0"; +"452 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/view_0" -> "453 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0"; +"453 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/permute_0" -> "454 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0"; +"454 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "455 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___0"; +"454 ShuffleNetV2/Sequential[layer3]/BasicBlock[1]/ShuffleBlock[shuffle]/reshape_0" -> "456 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___1"; +"455 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___0" -> "480 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0"; +"456 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SplitBlock[split]/__getitem___1" -> "459 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/conv2d_0"; +"457 layer3.2.conv1.weight" -> "458 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"458 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "459 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/conv2d_0"; +"459 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv1]/conv2d_0" -> "462 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"460 layer3.2.bn1.weight" -> "462 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"461 layer3.2.bn1.bias" -> "462 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0"; +"462 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn1]/batch_norm_0" -> "463 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_0"; +"463 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_0" -> "464 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0"; +"464 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_0" -> "467 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/conv2d_0"; +"465 layer3.2.conv2.weight" -> "466 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"466 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "467 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/conv2d_0"; +"467 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv2]/conv2d_0" -> "470 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"468 layer3.2.bn2.weight" -> "470 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"469 layer3.2.bn2.bias" -> "470 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0"; +"470 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/batch_norm_0" -> "471 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"471 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "474 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/conv2d_0"; +"472 layer3.2.conv3.weight" -> "473 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"473 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "474 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/conv2d_0"; +"474 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/Conv2d[conv3]/conv2d_0" -> "477 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"475 layer3.2.bn3.weight" -> "477 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"476 layer3.2.bn3.bias" -> "477 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0"; +"477 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/BatchNorm2d[bn3]/batch_norm_0" -> "478 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_1"; +"478 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/relu_1" -> "479 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1"; +"479 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/SymmetricQuantizer/symmetric_quantize_1" -> "480 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0"; +"480 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/cat_0" -> "481 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0"; +"481 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/view_0" -> "482 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0"; +"482 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/permute_0" -> "483 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0"; +"483 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "484 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___0"; +"483 ShuffleNetV2/Sequential[layer3]/BasicBlock[2]/ShuffleBlock[shuffle]/reshape_0" -> "485 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___1"; +"484 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___0" -> "509 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0"; +"485 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SplitBlock[split]/__getitem___1" -> "488 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/conv2d_0"; +"486 layer3.3.conv1.weight" -> "487 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0"; +"487 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/SymmetricQuantizer/symmetric_quantize_0" -> "488 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/conv2d_0"; +"488 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv1]/conv2d_0" -> "491 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"489 layer3.3.bn1.weight" -> "491 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"490 layer3.3.bn1.bias" -> "491 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0"; +"491 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn1]/batch_norm_0" -> "492 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_0"; +"492 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_0" -> "493 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0"; +"493 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_0" -> "496 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/conv2d_0"; +"494 layer3.3.conv2.weight" -> "495 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"495 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "496 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/conv2d_0"; +"496 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv2]/conv2d_0" -> "499 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"497 layer3.3.bn2.weight" -> "499 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"498 layer3.3.bn2.bias" -> "499 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0"; +"499 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/batch_norm_0" -> "500 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0"; +"500 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn2]/SymmetricQuantizer/symmetric_quantize_0" -> "503 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/conv2d_0"; +"501 layer3.3.conv3.weight" -> "502 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0"; +"502 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/SymmetricQuantizer/symmetric_quantize_0" -> "503 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/conv2d_0"; +"503 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/Conv2d[conv3]/conv2d_0" -> "506 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"504 layer3.3.bn3.weight" -> "506 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"505 layer3.3.bn3.bias" -> "506 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0"; +"506 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/BatchNorm2d[bn3]/batch_norm_0" -> "507 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_1"; +"507 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/relu_1" -> "508 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1"; +"508 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/SymmetricQuantizer/symmetric_quantize_1" -> "509 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0"; +"509 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/cat_0" -> "510 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0"; +"510 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/view_0" -> "511 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0"; +"511 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/permute_0" -> "512 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0"; +"512 ShuffleNetV2/Sequential[layer3]/BasicBlock[3]/ShuffleBlock[shuffle]/reshape_0" -> "515 ShuffleNetV2/Conv2d[conv2]/conv2d_0"; +"513 conv2.weight" -> "514 ShuffleNetV2/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0"; +"514 ShuffleNetV2/Conv2d[conv2]/SymmetricQuantizer/symmetric_quantize_0" -> "515 ShuffleNetV2/Conv2d[conv2]/conv2d_0"; +"515 ShuffleNetV2/Conv2d[conv2]/conv2d_0" -> "518 ShuffleNetV2/BatchNorm2d[bn2]/batch_norm_0"; +"516 bn2.weight" -> "518 ShuffleNetV2/BatchNorm2d[bn2]/batch_norm_0"; +"517 bn2.bias" -> "518 ShuffleNetV2/BatchNorm2d[bn2]/batch_norm_0"; +"518 ShuffleNetV2/BatchNorm2d[bn2]/batch_norm_0" -> "519 ShuffleNetV2/relu_1"; +"519 ShuffleNetV2/relu_1" -> "520 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_1|OUTPUT]/symmetric_quantize_0"; +"520 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/relu_1|OUTPUT]/symmetric_quantize_0" -> "521 ShuffleNetV2/avg_pool2d_0"; +"521 ShuffleNetV2/avg_pool2d_0" -> "522 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/avg_pool2d_0|OUTPUT]/symmetric_quantize_0"; +"522 ShuffleNetV2/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[ShuffleNetV2/avg_pool2d_0|OUTPUT]/symmetric_quantize_0" -> "523 ShuffleNetV2/view_0"; +"523 ShuffleNetV2/view_0" -> "527 ShuffleNetV2/Linear[linear]/linear_0"; +"524 linear.weight" -> "526 ShuffleNetV2/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0"; +"525 linear.bias" -> "527 ShuffleNetV2/Linear[linear]/linear_0"; +"526 ShuffleNetV2/Linear[linear]/SymmetricQuantizer/symmetric_quantize_0" -> "527 ShuffleNetV2/Linear[linear]/linear_0"; +"527 ShuffleNetV2/Linear[linear]/linear_0" -> "528 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/squeezenet1_1.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/squeezenet1_1.dot index 66ce128ef93..a5de426be6b 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/squeezenet1_1.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/squeezenet1_1.dot @@ -1,251 +1,355 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 SqueezeNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 SqueezeNet/Sequential[features]/ReLU[1]/relu__0" [id=4, type=relu_]; -"5 SqueezeNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" [id=5, type=symmetric_quantize]; -"6 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" [id=6, type=max_pool2d]; -"7 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d_0" [id=8, type=conv2d]; -"9 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/relu__0" [id=9, type=relu_]; -"10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; -"11 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d_0" [id=12, type=conv2d]; -"13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/relu__0" [id=13, type=relu_]; -"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=14, type=symmetric_quantize]; -"15 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=15, type=symmetric_quantize]; -"16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d_0" [id=16, type=conv2d]; -"17 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/relu__0" [id=17, type=relu_]; -"18 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=18, type=symmetric_quantize]; -"19 SqueezeNet/Sequential[features]/Fire[3]/cat_0" [id=19, type=cat]; -"20 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d_0" [id=21, type=conv2d]; -"22 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/relu__0" [id=22, type=relu_]; -"23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; -"24 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d_0" [id=25, type=conv2d]; -"26 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/relu__0" [id=26, type=relu_]; -"27 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=27, type=symmetric_quantize]; -"28 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=28, type=symmetric_quantize]; -"29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d_0" [id=29, type=conv2d]; -"30 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/relu__0" [id=30, type=relu_]; -"31 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; -"32 SqueezeNet/Sequential[features]/Fire[4]/cat_0" [id=32, type=cat]; -"33 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" [id=33, type=max_pool2d]; -"34 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=34, type=symmetric_quantize]; -"35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d_0" [id=35, type=conv2d]; -"36 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/relu__0" [id=36, type=relu_]; -"37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=37, type=symmetric_quantize]; -"38 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=38, type=symmetric_quantize]; -"39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d_0" [id=39, type=conv2d]; -"40 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/relu__0" [id=40, type=relu_]; -"41 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=41, type=symmetric_quantize]; -"42 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=42, type=symmetric_quantize]; -"43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d_0" [id=43, type=conv2d]; -"44 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/relu__0" [id=44, type=relu_]; -"45 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=45, type=symmetric_quantize]; -"46 SqueezeNet/Sequential[features]/Fire[6]/cat_0" [id=46, type=cat]; -"47 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=47, type=symmetric_quantize]; -"48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d_0" [id=48, type=conv2d]; -"49 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/relu__0" [id=49, type=relu_]; -"50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; -"51 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; -"52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d_0" [id=52, type=conv2d]; -"53 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/relu__0" [id=53, type=relu_]; -"54 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; -"55 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=55, type=symmetric_quantize]; -"56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d_0" [id=56, type=conv2d]; -"57 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/relu__0" [id=57, type=relu_]; -"58 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=58, type=symmetric_quantize]; -"59 SqueezeNet/Sequential[features]/Fire[7]/cat_0" [id=59, type=cat]; -"60 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d_0" [id=60, type=max_pool2d]; -"61 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; -"62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d_0" [id=62, type=conv2d]; -"63 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/relu__0" [id=63, type=relu_]; -"64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d_0" [id=66, type=conv2d]; -"67 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/relu__0" [id=67, type=relu_]; -"68 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; -"69 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d_0" [id=70, type=conv2d]; -"71 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/relu__0" [id=71, type=relu_]; -"72 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=72, type=symmetric_quantize]; -"73 SqueezeNet/Sequential[features]/Fire[9]/cat_0" [id=73, type=cat]; -"74 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=74, type=symmetric_quantize]; -"75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d_0" [id=75, type=conv2d]; -"76 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/relu__0" [id=76, type=relu_]; -"77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=77, type=symmetric_quantize]; -"78 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=78, type=symmetric_quantize]; -"79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d_0" [id=79, type=conv2d]; -"80 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/relu__0" [id=80, type=relu_]; -"81 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=81, type=symmetric_quantize]; -"82 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=82, type=symmetric_quantize]; -"83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d_0" [id=83, type=conv2d]; -"84 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/relu__0" [id=84, type=relu_]; -"85 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 SqueezeNet/Sequential[features]/Fire[10]/cat_0" [id=86, type=cat]; -"87 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=87, type=symmetric_quantize]; -"88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d_0" [id=88, type=conv2d]; -"89 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/relu__0" [id=89, type=relu_]; -"90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=90, type=symmetric_quantize]; -"91 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d_0" [id=92, type=conv2d]; -"93 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/relu__0" [id=93, type=relu_]; -"94 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; -"95 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=95, type=symmetric_quantize]; -"96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d_0" [id=96, type=conv2d]; -"97 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/relu__0" [id=97, type=relu_]; -"98 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=98, type=symmetric_quantize]; -"99 SqueezeNet/Sequential[features]/Fire[11]/cat_0" [id=99, type=cat]; -"100 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d_0" [id=101, type=conv2d]; -"102 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/relu__0" [id=102, type=relu_]; -"103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=103, type=symmetric_quantize]; -"104 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=104, type=symmetric_quantize]; -"105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d_0" [id=105, type=conv2d]; -"106 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/relu__0" [id=106, type=relu_]; -"107 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=107, type=symmetric_quantize]; -"108 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=108, type=symmetric_quantize]; -"109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d_0" [id=109, type=conv2d]; -"110 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/relu__0" [id=110, type=relu_]; -"111 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 SqueezeNet/Sequential[features]/Fire[12]/cat_0" [id=112, type=cat]; -"113 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout_0" [id=113, type=dropout]; -"114 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=114, type=symmetric_quantize]; -"115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d_0" [id=115, type=conv2d]; -"116 SqueezeNet/Sequential[classifier]/ReLU[2]/relu__0" [id=116, type=relu_]; -"117 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d_0" [id=118, type=adaptive_avg_pool2d]; -"119 SqueezeNet/view_0" [id=119, type=view]; -"120 /nncf_model_output_0" [id=120, type=nncf_model_output]; +"2 features.0.weight" [id=2, type=nncf_model_const]; +"3 features.0.bias" [id=3, type=nncf_model_const]; +"4 SqueezeNet/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 SqueezeNet/Sequential[features]/Conv2d[0]/conv2d_0" [id=5, type=conv2d]; +"6 SqueezeNet/Sequential[features]/ReLU[1]/relu__0" [id=6, type=relu_]; +"7 SqueezeNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" [id=8, type=max_pool2d]; +"9 features.3.squeeze.weight" [id=9, type=nncf_model_const]; +"10 features.3.squeeze.bias" [id=10, type=nncf_model_const]; +"11 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; +"12 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/conv2d_0" [id=12, type=conv2d]; +"13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/relu__0" [id=13, type=relu_]; +"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=14, type=symmetric_quantize]; +"15 features.3.expand1x1.weight" [id=15, type=nncf_model_const]; +"16 features.3.expand1x1.bias" [id=16, type=nncf_model_const]; +"17 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=17, type=symmetric_quantize]; +"18 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/conv2d_0" [id=18, type=conv2d]; +"19 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/relu__0" [id=19, type=relu_]; +"20 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 features.3.expand3x3.weight" [id=21, type=nncf_model_const]; +"22 features.3.expand3x3.bias" [id=22, type=nncf_model_const]; +"23 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; +"24 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/conv2d_0" [id=24, type=conv2d]; +"25 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/relu__0" [id=25, type=relu_]; +"26 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 SqueezeNet/Sequential[features]/Fire[3]/cat_0" [id=27, type=cat]; +"28 features.4.squeeze.weight" [id=28, type=nncf_model_const]; +"29 features.4.squeeze.bias" [id=29, type=nncf_model_const]; +"30 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/conv2d_0" [id=31, type=conv2d]; +"32 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/relu__0" [id=32, type=relu_]; +"33 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; +"34 features.4.expand1x1.weight" [id=34, type=nncf_model_const]; +"35 features.4.expand1x1.bias" [id=35, type=nncf_model_const]; +"36 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; +"37 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/conv2d_0" [id=37, type=conv2d]; +"38 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/relu__0" [id=38, type=relu_]; +"39 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 features.4.expand3x3.weight" [id=40, type=nncf_model_const]; +"41 features.4.expand3x3.bias" [id=41, type=nncf_model_const]; +"42 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/conv2d_0" [id=43, type=conv2d]; +"44 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/relu__0" [id=44, type=relu_]; +"45 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=45, type=symmetric_quantize]; +"46 SqueezeNet/Sequential[features]/Fire[4]/cat_0" [id=46, type=cat]; +"47 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" [id=47, type=max_pool2d]; +"48 features.6.squeeze.weight" [id=48, type=nncf_model_const]; +"49 features.6.squeeze.bias" [id=49, type=nncf_model_const]; +"50 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; +"51 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/conv2d_0" [id=51, type=conv2d]; +"52 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/relu__0" [id=52, type=relu_]; +"53 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=53, type=symmetric_quantize]; +"54 features.6.expand1x1.weight" [id=54, type=nncf_model_const]; +"55 features.6.expand1x1.bias" [id=55, type=nncf_model_const]; +"56 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/conv2d_0" [id=57, type=conv2d]; +"58 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/relu__0" [id=58, type=relu_]; +"59 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=59, type=symmetric_quantize]; +"60 features.6.expand3x3.weight" [id=60, type=nncf_model_const]; +"61 features.6.expand3x3.bias" [id=61, type=nncf_model_const]; +"62 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=62, type=symmetric_quantize]; +"63 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/conv2d_0" [id=63, type=conv2d]; +"64 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/relu__0" [id=64, type=relu_]; +"65 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=65, type=symmetric_quantize]; +"66 SqueezeNet/Sequential[features]/Fire[6]/cat_0" [id=66, type=cat]; +"67 features.7.squeeze.weight" [id=67, type=nncf_model_const]; +"68 features.7.squeeze.bias" [id=68, type=nncf_model_const]; +"69 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; +"70 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/conv2d_0" [id=70, type=conv2d]; +"71 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/relu__0" [id=71, type=relu_]; +"72 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=72, type=symmetric_quantize]; +"73 features.7.expand1x1.weight" [id=73, type=nncf_model_const]; +"74 features.7.expand1x1.bias" [id=74, type=nncf_model_const]; +"75 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=75, type=symmetric_quantize]; +"76 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/conv2d_0" [id=76, type=conv2d]; +"77 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/relu__0" [id=77, type=relu_]; +"78 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=78, type=symmetric_quantize]; +"79 features.7.expand3x3.weight" [id=79, type=nncf_model_const]; +"80 features.7.expand3x3.bias" [id=80, type=nncf_model_const]; +"81 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=81, type=symmetric_quantize]; +"82 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/conv2d_0" [id=82, type=conv2d]; +"83 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/relu__0" [id=83, type=relu_]; +"84 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 SqueezeNet/Sequential[features]/Fire[7]/cat_0" [id=85, type=cat]; +"86 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d_0" [id=86, type=max_pool2d]; +"87 features.9.squeeze.weight" [id=87, type=nncf_model_const]; +"88 features.9.squeeze.bias" [id=88, type=nncf_model_const]; +"89 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=89, type=symmetric_quantize]; +"90 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/conv2d_0" [id=90, type=conv2d]; +"91 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/relu__0" [id=91, type=relu_]; +"92 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=92, type=symmetric_quantize]; +"93 features.9.expand1x1.weight" [id=93, type=nncf_model_const]; +"94 features.9.expand1x1.bias" [id=94, type=nncf_model_const]; +"95 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=95, type=symmetric_quantize]; +"96 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/conv2d_0" [id=96, type=conv2d]; +"97 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/relu__0" [id=97, type=relu_]; +"98 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=98, type=symmetric_quantize]; +"99 features.9.expand3x3.weight" [id=99, type=nncf_model_const]; +"100 features.9.expand3x3.bias" [id=100, type=nncf_model_const]; +"101 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/conv2d_0" [id=102, type=conv2d]; +"103 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/relu__0" [id=103, type=relu_]; +"104 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=104, type=symmetric_quantize]; +"105 SqueezeNet/Sequential[features]/Fire[9]/cat_0" [id=105, type=cat]; +"106 features.10.squeeze.weight" [id=106, type=nncf_model_const]; +"107 features.10.squeeze.bias" [id=107, type=nncf_model_const]; +"108 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=108, type=symmetric_quantize]; +"109 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/conv2d_0" [id=109, type=conv2d]; +"110 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/relu__0" [id=110, type=relu_]; +"111 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 features.10.expand1x1.weight" [id=112, type=nncf_model_const]; +"113 features.10.expand1x1.bias" [id=113, type=nncf_model_const]; +"114 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/conv2d_0" [id=115, type=conv2d]; +"116 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/relu__0" [id=116, type=relu_]; +"117 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=117, type=symmetric_quantize]; +"118 features.10.expand3x3.weight" [id=118, type=nncf_model_const]; +"119 features.10.expand3x3.bias" [id=119, type=nncf_model_const]; +"120 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/conv2d_0" [id=121, type=conv2d]; +"122 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/relu__0" [id=122, type=relu_]; +"123 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 SqueezeNet/Sequential[features]/Fire[10]/cat_0" [id=124, type=cat]; +"125 features.11.squeeze.weight" [id=125, type=nncf_model_const]; +"126 features.11.squeeze.bias" [id=126, type=nncf_model_const]; +"127 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=127, type=symmetric_quantize]; +"128 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/conv2d_0" [id=128, type=conv2d]; +"129 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/relu__0" [id=129, type=relu_]; +"130 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=130, type=symmetric_quantize]; +"131 features.11.expand1x1.weight" [id=131, type=nncf_model_const]; +"132 features.11.expand1x1.bias" [id=132, type=nncf_model_const]; +"133 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=133, type=symmetric_quantize]; +"134 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/conv2d_0" [id=134, type=conv2d]; +"135 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/relu__0" [id=135, type=relu_]; +"136 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=136, type=symmetric_quantize]; +"137 features.11.expand3x3.weight" [id=137, type=nncf_model_const]; +"138 features.11.expand3x3.bias" [id=138, type=nncf_model_const]; +"139 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/conv2d_0" [id=140, type=conv2d]; +"141 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/relu__0" [id=141, type=relu_]; +"142 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; +"143 SqueezeNet/Sequential[features]/Fire[11]/cat_0" [id=143, type=cat]; +"144 features.12.squeeze.weight" [id=144, type=nncf_model_const]; +"145 features.12.squeeze.bias" [id=145, type=nncf_model_const]; +"146 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" [id=146, type=symmetric_quantize]; +"147 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/conv2d_0" [id=147, type=conv2d]; +"148 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/relu__0" [id=148, type=relu_]; +"149 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 features.12.expand1x1.weight" [id=150, type=nncf_model_const]; +"151 features.12.expand1x1.bias" [id=151, type=nncf_model_const]; +"152 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" [id=152, type=symmetric_quantize]; +"153 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/conv2d_0" [id=153, type=conv2d]; +"154 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/relu__0" [id=154, type=relu_]; +"155 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; +"156 features.12.expand3x3.weight" [id=156, type=nncf_model_const]; +"157 features.12.expand3x3.bias" [id=157, type=nncf_model_const]; +"158 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" [id=158, type=symmetric_quantize]; +"159 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/conv2d_0" [id=159, type=conv2d]; +"160 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/relu__0" [id=160, type=relu_]; +"161 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 SqueezeNet/Sequential[features]/Fire[12]/cat_0" [id=162, type=cat]; +"163 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout_0" [id=163, type=dropout]; +"164 classifier.1.weight" [id=164, type=nncf_model_const]; +"165 classifier.1.bias" [id=165, type=nncf_model_const]; +"166 SqueezeNet/Sequential[classifier]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=166, type=symmetric_quantize]; +"167 SqueezeNet/Sequential[classifier]/Conv2d[1]/conv2d_0" [id=167, type=conv2d]; +"168 SqueezeNet/Sequential[classifier]/ReLU[2]/relu__0" [id=168, type=relu_]; +"169 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=169, type=symmetric_quantize]; +"170 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d_0" [id=170, type=adaptive_avg_pool2d]; +"171 SqueezeNet/view_0" [id=171, type=view]; +"172 /nncf_model_output_0" [id=172, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d_0"; -"2 SqueezeNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d_0"; -"3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d_0" -> "4 SqueezeNet/Sequential[features]/ReLU[1]/relu__0"; -"4 SqueezeNet/Sequential[features]/ReLU[1]/relu__0" -> "5 SqueezeNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0"; -"5 SqueezeNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" -> "6 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0"; -"6 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" -> "8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d_0"; -"7 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d_0"; -"8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d_0" -> "9 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/relu__0"; -"9 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/relu__0" -> "10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d_0"; -"10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d_0"; -"11 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d_0"; -"12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d_0" -> "13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/relu__0"; -"13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/relu__0" -> "14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "19 SqueezeNet/Sequential[features]/Fire[3]/cat_0"; -"15 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d_0"; -"16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d_0" -> "17 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/relu__0"; -"17 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/relu__0" -> "18 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"18 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "19 SqueezeNet/Sequential[features]/Fire[3]/cat_0"; -"19 SqueezeNet/Sequential[features]/Fire[3]/cat_0" -> "21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d_0"; -"20 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d_0"; -"21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d_0" -> "22 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/relu__0"; -"22 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/relu__0" -> "23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d_0"; -"23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d_0"; -"24 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d_0"; -"25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d_0" -> "26 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/relu__0"; -"26 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/relu__0" -> "27 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"27 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "32 SqueezeNet/Sequential[features]/Fire[4]/cat_0"; -"28 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d_0"; -"29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d_0" -> "30 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/relu__0"; -"30 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/relu__0" -> "31 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"31 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "32 SqueezeNet/Sequential[features]/Fire[4]/cat_0"; -"32 SqueezeNet/Sequential[features]/Fire[4]/cat_0" -> "33 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0"; -"33 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" -> "35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d_0"; -"34 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d_0"; -"35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d_0" -> "36 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/relu__0"; -"36 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/relu__0" -> "37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d_0"; -"37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d_0"; -"38 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d_0"; -"39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d_0" -> "40 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/relu__0"; -"40 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/relu__0" -> "41 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"41 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "46 SqueezeNet/Sequential[features]/Fire[6]/cat_0"; -"42 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d_0"; -"43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d_0" -> "44 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/relu__0"; -"44 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/relu__0" -> "45 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"45 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "46 SqueezeNet/Sequential[features]/Fire[6]/cat_0"; -"46 SqueezeNet/Sequential[features]/Fire[6]/cat_0" -> "48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d_0"; -"47 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d_0"; -"48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d_0" -> "49 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/relu__0"; -"49 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/relu__0" -> "50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d_0"; -"50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d_0"; -"51 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d_0"; -"52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d_0" -> "53 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/relu__0"; -"53 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/relu__0" -> "54 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"54 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "59 SqueezeNet/Sequential[features]/Fire[7]/cat_0"; -"55 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d_0"; -"56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d_0" -> "57 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/relu__0"; -"57 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/relu__0" -> "58 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"58 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "59 SqueezeNet/Sequential[features]/Fire[7]/cat_0"; -"59 SqueezeNet/Sequential[features]/Fire[7]/cat_0" -> "60 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d_0"; -"60 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d_0" -> "62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d_0"; -"61 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d_0"; -"62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d_0" -> "63 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/relu__0"; -"63 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/relu__0" -> "64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d_0"; -"64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d_0"; -"65 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d_0"; -"66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d_0" -> "67 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/relu__0"; -"67 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/relu__0" -> "68 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"68 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "73 SqueezeNet/Sequential[features]/Fire[9]/cat_0"; -"69 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d_0"; -"70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d_0" -> "71 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/relu__0"; -"71 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/relu__0" -> "72 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"72 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "73 SqueezeNet/Sequential[features]/Fire[9]/cat_0"; -"73 SqueezeNet/Sequential[features]/Fire[9]/cat_0" -> "75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d_0"; -"74 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d_0"; -"75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d_0" -> "76 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/relu__0"; -"76 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/relu__0" -> "77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d_0"; -"77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d_0"; -"78 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d_0"; -"79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d_0" -> "80 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/relu__0"; -"80 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/relu__0" -> "81 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"81 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "86 SqueezeNet/Sequential[features]/Fire[10]/cat_0"; -"82 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d_0"; -"83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d_0" -> "84 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/relu__0"; -"84 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/relu__0" -> "85 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"85 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "86 SqueezeNet/Sequential[features]/Fire[10]/cat_0"; -"86 SqueezeNet/Sequential[features]/Fire[10]/cat_0" -> "88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d_0"; -"87 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d_0"; -"88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d_0" -> "89 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/relu__0"; -"89 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/relu__0" -> "90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d_0"; -"90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d_0"; -"91 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d_0"; -"92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d_0" -> "93 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/relu__0"; -"93 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/relu__0" -> "94 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"94 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "99 SqueezeNet/Sequential[features]/Fire[11]/cat_0"; -"95 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d_0"; -"96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d_0" -> "97 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/relu__0"; -"97 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/relu__0" -> "98 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"98 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "99 SqueezeNet/Sequential[features]/Fire[11]/cat_0"; -"99 SqueezeNet/Sequential[features]/Fire[11]/cat_0" -> "101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d_0"; -"100 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d_0"; -"101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d_0" -> "102 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/relu__0"; -"102 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/relu__0" -> "103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d_0"; -"103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d_0"; -"104 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d_0"; -"105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d_0" -> "106 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/relu__0"; -"106 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/relu__0" -> "107 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"107 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "112 SqueezeNet/Sequential[features]/Fire[12]/cat_0"; -"108 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d_0"; -"109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d_0" -> "110 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/relu__0"; -"110 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/relu__0" -> "111 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; -"111 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "112 SqueezeNet/Sequential[features]/Fire[12]/cat_0"; -"112 SqueezeNet/Sequential[features]/Fire[12]/cat_0" -> "113 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout_0"; -"113 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout_0" -> "115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d_0"; -"114 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d_0"; -"115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d_0" -> "116 SqueezeNet/Sequential[classifier]/ReLU[2]/relu__0"; -"116 SqueezeNet/Sequential[classifier]/ReLU[2]/relu__0" -> "117 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"117 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "118 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d_0"; -"118 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d_0" -> "119 SqueezeNet/view_0"; -"119 SqueezeNet/view_0" -> "120 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 SqueezeNet/Sequential[features]/Conv2d[0]/conv2d_0"; +"2 features.0.weight" -> "4 SqueezeNet/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 features.0.bias" -> "5 SqueezeNet/Sequential[features]/Conv2d[0]/conv2d_0"; +"4 SqueezeNet/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "5 SqueezeNet/Sequential[features]/Conv2d[0]/conv2d_0"; +"5 SqueezeNet/Sequential[features]/Conv2d[0]/conv2d_0" -> "6 SqueezeNet/Sequential[features]/ReLU[1]/relu__0"; +"6 SqueezeNet/Sequential[features]/ReLU[1]/relu__0" -> "7 SqueezeNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0"; +"7 SqueezeNet/Sequential[features]/ReLU[1]/SymmetricQuantizer/symmetric_quantize_0" -> "8 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0"; +"8 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d_0" -> "12 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/conv2d_0"; +"9 features.3.squeeze.weight" -> "11 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"10 features.3.squeeze.bias" -> "12 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/conv2d_0"; +"11 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "12 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/conv2d_0"; +"12 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[squeeze]/conv2d_0" -> "13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/relu__0"; +"13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/relu__0" -> "14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "18 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/conv2d_0"; +"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "24 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/conv2d_0"; +"15 features.3.expand1x1.weight" -> "17 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"16 features.3.expand1x1.bias" -> "18 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/conv2d_0"; +"17 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "18 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/conv2d_0"; +"18 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand1x1]/conv2d_0" -> "19 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/relu__0"; +"19 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/relu__0" -> "20 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"20 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "27 SqueezeNet/Sequential[features]/Fire[3]/cat_0"; +"21 features.3.expand3x3.weight" -> "23 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"22 features.3.expand3x3.bias" -> "24 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/conv2d_0"; +"23 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "24 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/conv2d_0"; +"24 SqueezeNet/Sequential[features]/Fire[3]/Conv2d[expand3x3]/conv2d_0" -> "25 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/relu__0"; +"25 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/relu__0" -> "26 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"26 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "27 SqueezeNet/Sequential[features]/Fire[3]/cat_0"; +"27 SqueezeNet/Sequential[features]/Fire[3]/cat_0" -> "31 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/conv2d_0"; +"28 features.4.squeeze.weight" -> "30 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"29 features.4.squeeze.bias" -> "31 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/conv2d_0"; +"30 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "31 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/conv2d_0"; +"31 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[squeeze]/conv2d_0" -> "32 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/relu__0"; +"32 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/relu__0" -> "33 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"33 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "37 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/conv2d_0"; +"33 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "43 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/conv2d_0"; +"34 features.4.expand1x1.weight" -> "36 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"35 features.4.expand1x1.bias" -> "37 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/conv2d_0"; +"36 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "37 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/conv2d_0"; +"37 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand1x1]/conv2d_0" -> "38 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/relu__0"; +"38 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/relu__0" -> "39 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"39 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "46 SqueezeNet/Sequential[features]/Fire[4]/cat_0"; +"40 features.4.expand3x3.weight" -> "42 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"41 features.4.expand3x3.bias" -> "43 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/conv2d_0"; +"42 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "43 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/conv2d_0"; +"43 SqueezeNet/Sequential[features]/Fire[4]/Conv2d[expand3x3]/conv2d_0" -> "44 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/relu__0"; +"44 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/relu__0" -> "45 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"45 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "46 SqueezeNet/Sequential[features]/Fire[4]/cat_0"; +"46 SqueezeNet/Sequential[features]/Fire[4]/cat_0" -> "47 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0"; +"47 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d_0" -> "51 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/conv2d_0"; +"48 features.6.squeeze.weight" -> "50 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"49 features.6.squeeze.bias" -> "51 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/conv2d_0"; +"50 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "51 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/conv2d_0"; +"51 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[squeeze]/conv2d_0" -> "52 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/relu__0"; +"52 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/relu__0" -> "53 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"53 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "57 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/conv2d_0"; +"53 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "63 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/conv2d_0"; +"54 features.6.expand1x1.weight" -> "56 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"55 features.6.expand1x1.bias" -> "57 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/conv2d_0"; +"56 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "57 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/conv2d_0"; +"57 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand1x1]/conv2d_0" -> "58 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/relu__0"; +"58 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/relu__0" -> "59 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"59 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "66 SqueezeNet/Sequential[features]/Fire[6]/cat_0"; +"60 features.6.expand3x3.weight" -> "62 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"61 features.6.expand3x3.bias" -> "63 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/conv2d_0"; +"62 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "63 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/conv2d_0"; +"63 SqueezeNet/Sequential[features]/Fire[6]/Conv2d[expand3x3]/conv2d_0" -> "64 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/relu__0"; +"64 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/relu__0" -> "65 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"65 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "66 SqueezeNet/Sequential[features]/Fire[6]/cat_0"; +"66 SqueezeNet/Sequential[features]/Fire[6]/cat_0" -> "70 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/conv2d_0"; +"67 features.7.squeeze.weight" -> "69 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"68 features.7.squeeze.bias" -> "70 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/conv2d_0"; +"69 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "70 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/conv2d_0"; +"70 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[squeeze]/conv2d_0" -> "71 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/relu__0"; +"71 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/relu__0" -> "72 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"72 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "76 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/conv2d_0"; +"72 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "82 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/conv2d_0"; +"73 features.7.expand1x1.weight" -> "75 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"74 features.7.expand1x1.bias" -> "76 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/conv2d_0"; +"75 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "76 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/conv2d_0"; +"76 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand1x1]/conv2d_0" -> "77 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/relu__0"; +"77 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/relu__0" -> "78 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"78 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "85 SqueezeNet/Sequential[features]/Fire[7]/cat_0"; +"79 features.7.expand3x3.weight" -> "81 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"80 features.7.expand3x3.bias" -> "82 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/conv2d_0"; +"81 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "82 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/conv2d_0"; +"82 SqueezeNet/Sequential[features]/Fire[7]/Conv2d[expand3x3]/conv2d_0" -> "83 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/relu__0"; +"83 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/relu__0" -> "84 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"84 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "85 SqueezeNet/Sequential[features]/Fire[7]/cat_0"; +"85 SqueezeNet/Sequential[features]/Fire[7]/cat_0" -> "86 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d_0"; +"86 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d_0" -> "90 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/conv2d_0"; +"87 features.9.squeeze.weight" -> "89 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"88 features.9.squeeze.bias" -> "90 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/conv2d_0"; +"89 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "90 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/conv2d_0"; +"90 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[squeeze]/conv2d_0" -> "91 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/relu__0"; +"91 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/relu__0" -> "92 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"92 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "96 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/conv2d_0"; +"92 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "102 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/conv2d_0"; +"93 features.9.expand1x1.weight" -> "95 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"94 features.9.expand1x1.bias" -> "96 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/conv2d_0"; +"95 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "96 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/conv2d_0"; +"96 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand1x1]/conv2d_0" -> "97 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/relu__0"; +"97 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/relu__0" -> "98 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"98 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "105 SqueezeNet/Sequential[features]/Fire[9]/cat_0"; +"99 features.9.expand3x3.weight" -> "101 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"100 features.9.expand3x3.bias" -> "102 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/conv2d_0"; +"101 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "102 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/conv2d_0"; +"102 SqueezeNet/Sequential[features]/Fire[9]/Conv2d[expand3x3]/conv2d_0" -> "103 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/relu__0"; +"103 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/relu__0" -> "104 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"104 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "105 SqueezeNet/Sequential[features]/Fire[9]/cat_0"; +"105 SqueezeNet/Sequential[features]/Fire[9]/cat_0" -> "109 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/conv2d_0"; +"106 features.10.squeeze.weight" -> "108 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"107 features.10.squeeze.bias" -> "109 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/conv2d_0"; +"108 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "109 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/conv2d_0"; +"109 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[squeeze]/conv2d_0" -> "110 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/relu__0"; +"110 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/relu__0" -> "111 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"111 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "115 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/conv2d_0"; +"111 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "121 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/conv2d_0"; +"112 features.10.expand1x1.weight" -> "114 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"113 features.10.expand1x1.bias" -> "115 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/conv2d_0"; +"114 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "115 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/conv2d_0"; +"115 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand1x1]/conv2d_0" -> "116 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/relu__0"; +"116 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/relu__0" -> "117 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"117 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "124 SqueezeNet/Sequential[features]/Fire[10]/cat_0"; +"118 features.10.expand3x3.weight" -> "120 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"119 features.10.expand3x3.bias" -> "121 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/conv2d_0"; +"120 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "121 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/conv2d_0"; +"121 SqueezeNet/Sequential[features]/Fire[10]/Conv2d[expand3x3]/conv2d_0" -> "122 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/relu__0"; +"122 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/relu__0" -> "123 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"123 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "124 SqueezeNet/Sequential[features]/Fire[10]/cat_0"; +"124 SqueezeNet/Sequential[features]/Fire[10]/cat_0" -> "128 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/conv2d_0"; +"125 features.11.squeeze.weight" -> "127 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"126 features.11.squeeze.bias" -> "128 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/conv2d_0"; +"127 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "128 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/conv2d_0"; +"128 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[squeeze]/conv2d_0" -> "129 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/relu__0"; +"129 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/relu__0" -> "130 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"130 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "134 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/conv2d_0"; +"130 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "140 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/conv2d_0"; +"131 features.11.expand1x1.weight" -> "133 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"132 features.11.expand1x1.bias" -> "134 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/conv2d_0"; +"133 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "134 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/conv2d_0"; +"134 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand1x1]/conv2d_0" -> "135 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/relu__0"; +"135 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/relu__0" -> "136 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"136 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "143 SqueezeNet/Sequential[features]/Fire[11]/cat_0"; +"137 features.11.expand3x3.weight" -> "139 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"138 features.11.expand3x3.bias" -> "140 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/conv2d_0"; +"139 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "140 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/conv2d_0"; +"140 SqueezeNet/Sequential[features]/Fire[11]/Conv2d[expand3x3]/conv2d_0" -> "141 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/relu__0"; +"141 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/relu__0" -> "142 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"142 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "143 SqueezeNet/Sequential[features]/Fire[11]/cat_0"; +"143 SqueezeNet/Sequential[features]/Fire[11]/cat_0" -> "147 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/conv2d_0"; +"144 features.12.squeeze.weight" -> "146 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0"; +"145 features.12.squeeze.bias" -> "147 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/conv2d_0"; +"146 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/SymmetricQuantizer/symmetric_quantize_0" -> "147 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/conv2d_0"; +"147 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[squeeze]/conv2d_0" -> "148 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/relu__0"; +"148 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/relu__0" -> "149 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"149 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "153 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/conv2d_0"; +"149 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "159 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/conv2d_0"; +"150 features.12.expand1x1.weight" -> "152 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0"; +"151 features.12.expand1x1.bias" -> "153 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/conv2d_0"; +"152 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/SymmetricQuantizer/symmetric_quantize_0" -> "153 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/conv2d_0"; +"153 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand1x1]/conv2d_0" -> "154 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/relu__0"; +"154 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/relu__0" -> "155 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"155 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "162 SqueezeNet/Sequential[features]/Fire[12]/cat_0"; +"156 features.12.expand3x3.weight" -> "158 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0"; +"157 features.12.expand3x3.bias" -> "159 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/conv2d_0"; +"158 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/SymmetricQuantizer/symmetric_quantize_0" -> "159 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/conv2d_0"; +"159 SqueezeNet/Sequential[features]/Fire[12]/Conv2d[expand3x3]/conv2d_0" -> "160 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/relu__0"; +"160 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/relu__0" -> "161 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0"; +"161 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/SymmetricQuantizer/symmetric_quantize_0" -> "162 SqueezeNet/Sequential[features]/Fire[12]/cat_0"; +"162 SqueezeNet/Sequential[features]/Fire[12]/cat_0" -> "163 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout_0"; +"163 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout_0" -> "167 SqueezeNet/Sequential[classifier]/Conv2d[1]/conv2d_0"; +"164 classifier.1.weight" -> "166 SqueezeNet/Sequential[classifier]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"165 classifier.1.bias" -> "167 SqueezeNet/Sequential[classifier]/Conv2d[1]/conv2d_0"; +"166 SqueezeNet/Sequential[classifier]/Conv2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "167 SqueezeNet/Sequential[classifier]/Conv2d[1]/conv2d_0"; +"167 SqueezeNet/Sequential[classifier]/Conv2d[1]/conv2d_0" -> "168 SqueezeNet/Sequential[classifier]/ReLU[2]/relu__0"; +"168 SqueezeNet/Sequential[classifier]/ReLU[2]/relu__0" -> "169 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"169 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "170 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d_0"; +"170 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d_0" -> "171 SqueezeNet/view_0"; +"171 SqueezeNet/view_0" -> "172 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_mobilenet.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_mobilenet.dot index 0261f818aa0..59cbd418897 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_mobilenet.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_mobilenet.dot @@ -4,496 +4,754 @@ strict digraph { "2 MobileNetSSD/__getitem___0" [id=2, type=__getitem__]; "3 MobileNetSSD/clone_0" [id=3, type=clone]; "4 MobileNetSSD/unsqueeze_0" [id=4, type=unsqueeze]; -"5 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=5, type=symmetric_quantize]; -"6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFConv2d[0]/conv2d_0" [id=6, type=conv2d]; -"7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=7, type=batch_norm]; -"8 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/relu__0" [id=8, type=relu_]; -"9 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=9, type=symmetric_quantize]; -"10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=10, type=symmetric_quantize]; -"11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[0]/conv2d_0" [id=11, type=conv2d]; -"12 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=12, type=batch_norm]; -"13 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/relu__0" [id=13, type=relu_]; -"14 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=14, type=symmetric_quantize]; -"15 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=15, type=symmetric_quantize]; -"16 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[3]/conv2d_0" [id=16, type=conv2d]; -"17 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFBatchNorm2d[4]/batch_norm_0" [id=17, type=batch_norm]; -"18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/relu__0" [id=18, type=relu_]; -"19 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; -"20 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[0]/conv2d_0" [id=21, type=conv2d]; -"22 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=22, type=batch_norm]; -"23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/relu__0" [id=23, type=relu_]; -"24 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[3]/conv2d_0" [id=26, type=conv2d]; -"27 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFBatchNorm2d[4]/batch_norm_0" [id=27, type=batch_norm]; -"28 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/relu__0" [id=28, type=relu_]; -"29 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=29, type=symmetric_quantize]; -"30 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=30, type=symmetric_quantize]; -"31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[0]/conv2d_0" [id=31, type=conv2d]; -"32 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=32, type=batch_norm]; -"33 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/relu__0" [id=33, type=relu_]; -"34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=34, type=symmetric_quantize]; -"35 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=35, type=symmetric_quantize]; -"36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[3]/conv2d_0" [id=36, type=conv2d]; -"37 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFBatchNorm2d[4]/batch_norm_0" [id=37, type=batch_norm]; -"38 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/relu__0" [id=38, type=relu_]; -"39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; -"40 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=40, type=symmetric_quantize]; -"41 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[0]/conv2d_0" [id=41, type=conv2d]; -"42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFBatchNorm2d[1]/batch_norm_0" [id=42, type=batch_norm]; -"43 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/relu__0" [id=43, type=relu_]; -"44 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=45, type=symmetric_quantize]; -"46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[3]/conv2d_0" [id=46, type=conv2d]; -"47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFBatchNorm2d[4]/batch_norm_0" [id=47, type=batch_norm]; -"48 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/relu__0" [id=48, type=relu_]; -"49 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=49, type=symmetric_quantize]; -"50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=50, type=symmetric_quantize]; -"51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[0]/conv2d_0" [id=51, type=conv2d]; -"52 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFBatchNorm2d[1]/batch_norm_0" [id=52, type=batch_norm]; -"53 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/relu__0" [id=53, type=relu_]; -"54 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; -"55 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=55, type=symmetric_quantize]; -"56 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[3]/conv2d_0" [id=56, type=conv2d]; -"57 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFBatchNorm2d[4]/batch_norm_0" [id=57, type=batch_norm]; -"58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/relu__0" [id=58, type=relu_]; -"59 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=59, type=symmetric_quantize]; -"60 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=60, type=symmetric_quantize]; -"61 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[0]/conv2d_0" [id=61, type=conv2d]; -"62 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFBatchNorm2d[1]/batch_norm_0" [id=62, type=batch_norm]; -"63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/relu__0" [id=63, type=relu_]; -"64 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[3]/conv2d_0" [id=66, type=conv2d]; -"67 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFBatchNorm2d[4]/batch_norm_0" [id=67, type=batch_norm]; -"68 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/relu__0" [id=68, type=relu_]; -"69 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=70, type=symmetric_quantize]; -"71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[0]/conv2d_0" [id=71, type=conv2d]; -"72 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFBatchNorm2d[1]/batch_norm_0" [id=72, type=batch_norm]; -"73 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/relu__0" [id=73, type=relu_]; -"74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; -"75 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[3]/conv2d_0" [id=76, type=conv2d]; -"77 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFBatchNorm2d[4]/batch_norm_0" [id=77, type=batch_norm]; -"78 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/relu__0" [id=78, type=relu_]; -"79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; -"80 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[0]/conv2d_0" [id=81, type=conv2d]; -"82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFBatchNorm2d[1]/batch_norm_0" [id=82, type=batch_norm]; -"83 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/relu__0" [id=83, type=relu_]; -"84 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; -"85 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[3]/conv2d_0" [id=86, type=conv2d]; -"87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFBatchNorm2d[4]/batch_norm_0" [id=87, type=batch_norm]; -"88 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/relu__0" [id=88, type=relu_]; -"89 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=89, type=symmetric_quantize]; -"90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=90, type=symmetric_quantize]; -"91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[0]/conv2d_0" [id=91, type=conv2d]; -"92 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFBatchNorm2d[1]/batch_norm_0" [id=92, type=batch_norm]; -"93 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/relu__0" [id=93, type=relu_]; -"94 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; -"95 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=95, type=symmetric_quantize]; -"96 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[3]/conv2d_0" [id=96, type=conv2d]; -"97 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFBatchNorm2d[4]/batch_norm_0" [id=97, type=batch_norm]; -"98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/relu__0" [id=98, type=relu_]; -"99 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=99, type=symmetric_quantize]; -"100 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[0]/conv2d_0" [id=101, type=conv2d]; -"102 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFBatchNorm2d[1]/batch_norm_0" [id=102, type=batch_norm]; -"103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/relu__0" [id=103, type=relu_]; -"104 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=104, type=symmetric_quantize]; -"105 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=105, type=symmetric_quantize]; -"106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[3]/conv2d_0" [id=106, type=conv2d]; -"107 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFBatchNorm2d[4]/batch_norm_0" [id=107, type=batch_norm]; -"108 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/relu__0" [id=108, type=relu_]; -"109 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=109, type=symmetric_quantize]; -"110 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=110, type=symmetric_quantize]; -"111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[0]/conv2d_0" [id=111, type=conv2d]; -"112 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFBatchNorm2d[1]/batch_norm_0" [id=112, type=batch_norm]; -"113 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/relu__0" [id=113, type=relu_]; -"114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; -"115 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=115, type=symmetric_quantize]; -"116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[3]/conv2d_0" [id=116, type=conv2d]; -"117 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFBatchNorm2d[4]/batch_norm_0" [id=117, type=batch_norm]; -"118 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/relu__0" [id=118, type=relu_]; -"119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=119, type=symmetric_quantize]; -"120 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=120, type=symmetric_quantize]; -"121 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[0]/conv2d_0" [id=121, type=conv2d]; -"122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFBatchNorm2d[1]/batch_norm_0" [id=122, type=batch_norm]; -"123 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/relu__0" [id=123, type=relu_]; -"124 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=124, type=symmetric_quantize]; -"125 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=125, type=symmetric_quantize]; -"126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[3]/conv2d_0" [id=126, type=conv2d]; -"127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFBatchNorm2d[4]/batch_norm_0" [id=127, type=batch_norm]; -"128 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/relu__0" [id=128, type=relu_]; -"129 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; -"130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=130, type=symmetric_quantize]; -"131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[0]/conv2d_0" [id=131, type=conv2d]; -"132 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFBatchNorm2d[1]/batch_norm_0" [id=132, type=batch_norm]; -"133 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/relu__0" [id=133, type=relu_]; -"134 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=134, type=symmetric_quantize]; -"135 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=135, type=symmetric_quantize]; -"136 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[3]/conv2d_0" [id=136, type=conv2d]; -"137 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFBatchNorm2d[4]/batch_norm_0" [id=137, type=batch_norm]; -"138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/relu__0" [id=138, type=relu_]; -"139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; -"140 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=140, type=symmetric_quantize]; -"141 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFConv2d[0]/conv2d_0" [id=141, type=conv2d]; -"142 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFBatchNorm2d[1]/batch_norm_0" [id=142, type=batch_norm]; -"143 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/relu__0" [id=143, type=relu_]; -"144 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=144, type=symmetric_quantize]; -"145 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=145, type=symmetric_quantize]; -"146 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFConv2d[0]/conv2d_0" [id=146, type=conv2d]; -"147 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFBatchNorm2d[1]/batch_norm_0" [id=147, type=batch_norm]; -"148 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/relu__0" [id=148, type=relu_]; -"149 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=149, type=symmetric_quantize]; -"150 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=150, type=symmetric_quantize]; -"151 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFConv2d[0]/conv2d_0" [id=151, type=conv2d]; -"152 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFBatchNorm2d[1]/batch_norm_0" [id=152, type=batch_norm]; -"153 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/relu__0" [id=153, type=relu_]; -"154 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=154, type=symmetric_quantize]; -"155 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=155, type=symmetric_quantize]; -"156 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFConv2d[0]/conv2d_0" [id=156, type=conv2d]; -"157 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFBatchNorm2d[1]/batch_norm_0" [id=157, type=batch_norm]; -"158 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/relu__0" [id=158, type=relu_]; -"159 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=159, type=symmetric_quantize]; -"160 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=160, type=symmetric_quantize]; -"161 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFConv2d[0]/conv2d_0" [id=161, type=conv2d]; -"162 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFBatchNorm2d[1]/batch_norm_0" [id=162, type=batch_norm]; -"163 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/relu__0" [id=163, type=relu_]; -"164 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=164, type=symmetric_quantize]; -"165 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=165, type=symmetric_quantize]; -"166 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFConv2d[0]/conv2d_0" [id=166, type=conv2d]; -"167 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFBatchNorm2d[1]/batch_norm_0" [id=167, type=batch_norm]; -"168 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/relu__0" [id=168, type=relu_]; -"169 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=169, type=symmetric_quantize]; -"170 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=170, type=symmetric_quantize]; -"171 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFConv2d[0]/conv2d_0" [id=171, type=conv2d]; -"172 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFBatchNorm2d[1]/batch_norm_0" [id=172, type=batch_norm]; -"173 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/relu__0" [id=173, type=relu_]; -"174 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=174, type=symmetric_quantize]; -"175 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=175, type=symmetric_quantize]; -"176 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFConv2d[0]/conv2d_0" [id=176, type=conv2d]; -"177 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFBatchNorm2d[1]/batch_norm_0" [id=177, type=batch_norm]; -"178 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/relu__0" [id=178, type=relu_]; -"179 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=179, type=symmetric_quantize]; -"180 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=180, type=symmetric_quantize]; -"181 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0" [id=181, type=conv2d]; -"182 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=182, type=symmetric_quantize]; -"183 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0" [id=183, type=conv2d]; -"184 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" [id=184, type=permute]; -"185 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" [id=185, type=contiguous]; -"186 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" [id=186, type=permute]; -"187 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" [id=187, type=contiguous]; -"188 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=188, type=symmetric_quantize]; -"189 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0" [id=189, type=conv2d]; -"190 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=190, type=symmetric_quantize]; -"191 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0" [id=191, type=conv2d]; -"192 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" [id=192, type=permute]; -"193 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" [id=193, type=contiguous]; -"194 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" [id=194, type=permute]; -"195 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" [id=195, type=contiguous]; -"196 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=196, type=symmetric_quantize]; -"197 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0" [id=197, type=conv2d]; -"198 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=198, type=symmetric_quantize]; -"199 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0" [id=199, type=conv2d]; -"200 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" [id=200, type=permute]; -"201 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" [id=201, type=contiguous]; -"202 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" [id=202, type=permute]; -"203 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" [id=203, type=contiguous]; -"204 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=204, type=symmetric_quantize]; -"205 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0" [id=205, type=conv2d]; -"206 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=206, type=symmetric_quantize]; -"207 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0" [id=207, type=conv2d]; -"208 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" [id=208, type=permute]; -"209 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" [id=209, type=contiguous]; -"210 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" [id=210, type=permute]; -"211 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" [id=211, type=contiguous]; -"212 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=212, type=symmetric_quantize]; -"213 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0" [id=213, type=conv2d]; -"214 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=214, type=symmetric_quantize]; -"215 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0" [id=215, type=conv2d]; -"216 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" [id=216, type=permute]; -"217 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" [id=217, type=contiguous]; -"218 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" [id=218, type=permute]; -"219 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" [id=219, type=contiguous]; -"220 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=220, type=symmetric_quantize]; -"221 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0" [id=221, type=conv2d]; -"222 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=222, type=symmetric_quantize]; -"223 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0" [id=223, type=conv2d]; -"224 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" [id=224, type=permute]; -"225 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" [id=225, type=contiguous]; -"226 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" [id=226, type=permute]; -"227 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" [id=227, type=contiguous]; -"228 MobileNetSSD/SSDDetectionOutput[detection_head]/view_0" [id=228, type=view]; -"229 MobileNetSSD/SSDDetectionOutput[detection_head]/view_1" [id=229, type=view]; -"230 MobileNetSSD/SSDDetectionOutput[detection_head]/view_2" [id=230, type=view]; -"231 MobileNetSSD/SSDDetectionOutput[detection_head]/view_3" [id=231, type=view]; -"232 MobileNetSSD/SSDDetectionOutput[detection_head]/view_4" [id=232, type=view]; -"233 MobileNetSSD/SSDDetectionOutput[detection_head]/view_5" [id=233, type=view]; -"234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0" [id=234, type=cat]; -"235 MobileNetSSD/SSDDetectionOutput[detection_head]/view_6" [id=235, type=view]; -"236 MobileNetSSD/SSDDetectionOutput[detection_head]/view_7" [id=236, type=view]; -"237 MobileNetSSD/SSDDetectionOutput[detection_head]/view_8" [id=237, type=view]; -"238 MobileNetSSD/SSDDetectionOutput[detection_head]/view_9" [id=238, type=view]; -"239 MobileNetSSD/SSDDetectionOutput[detection_head]/view_10" [id=239, type=view]; -"240 MobileNetSSD/SSDDetectionOutput[detection_head]/view_11" [id=240, type=view]; -"241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1" [id=241, type=cat]; -"242 MobileNetSSD/SSDDetectionOutput[detection_head]/view_12" [id=242, type=view]; -"243 MobileNetSSD/SSDDetectionOutput[detection_head]/softmax_0" [id=243, type=softmax]; +"5 basenet.0.0.weight" [id=5, type=nncf_model_const]; +"6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; +"7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/conv2d_0" [id=7, type=conv2d]; +"8 basenet.0.1.weight" [id=8, type=nncf_model_const]; +"9 basenet.0.1.bias" [id=9, type=nncf_model_const]; +"10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/BatchNorm2d[1]/batch_norm_0" [id=10, type=batch_norm]; +"11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/relu__0" [id=11, type=relu_]; +"12 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 basenet.1.0.weight" [id=13, type=nncf_model_const]; +"14 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=14, type=symmetric_quantize]; +"15 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/conv2d_0" [id=15, type=conv2d]; +"16 basenet.1.1.weight" [id=16, type=nncf_model_const]; +"17 basenet.1.1.bias" [id=17, type=nncf_model_const]; +"18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[1]/batch_norm_0" [id=18, type=batch_norm]; +"19 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/relu__0" [id=19, type=relu_]; +"20 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 basenet.1.3.weight" [id=21, type=nncf_model_const]; +"22 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/conv2d_0" [id=23, type=conv2d]; +"24 basenet.1.4.weight" [id=24, type=nncf_model_const]; +"25 basenet.1.4.bias" [id=25, type=nncf_model_const]; +"26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[4]/batch_norm_0" [id=26, type=batch_norm]; +"27 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/relu__0" [id=27, type=relu_]; +"28 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; +"29 basenet.2.0.weight" [id=29, type=nncf_model_const]; +"30 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=30, type=symmetric_quantize]; +"31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/conv2d_0" [id=31, type=conv2d]; +"32 basenet.2.1.weight" [id=32, type=nncf_model_const]; +"33 basenet.2.1.bias" [id=33, type=nncf_model_const]; +"34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[1]/batch_norm_0" [id=34, type=batch_norm]; +"35 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/relu__0" [id=35, type=relu_]; +"36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; +"37 basenet.2.3.weight" [id=37, type=nncf_model_const]; +"38 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/conv2d_0" [id=39, type=conv2d]; +"40 basenet.2.4.weight" [id=40, type=nncf_model_const]; +"41 basenet.2.4.bias" [id=41, type=nncf_model_const]; +"42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[4]/batch_norm_0" [id=42, type=batch_norm]; +"43 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/relu__0" [id=43, type=relu_]; +"44 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; +"45 basenet.3.0.weight" [id=45, type=nncf_model_const]; +"46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/conv2d_0" [id=47, type=conv2d]; +"48 basenet.3.1.weight" [id=48, type=nncf_model_const]; +"49 basenet.3.1.bias" [id=49, type=nncf_model_const]; +"50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[1]/batch_norm_0" [id=50, type=batch_norm]; +"51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/relu__0" [id=51, type=relu_]; +"52 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; +"53 basenet.3.3.weight" [id=53, type=nncf_model_const]; +"54 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; +"55 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/conv2d_0" [id=55, type=conv2d]; +"56 basenet.3.4.weight" [id=56, type=nncf_model_const]; +"57 basenet.3.4.bias" [id=57, type=nncf_model_const]; +"58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[4]/batch_norm_0" [id=58, type=batch_norm]; +"59 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/relu__0" [id=59, type=relu_]; +"60 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 basenet.4.0.weight" [id=61, type=nncf_model_const]; +"62 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=62, type=symmetric_quantize]; +"63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/conv2d_0" [id=63, type=conv2d]; +"64 basenet.4.1.weight" [id=64, type=nncf_model_const]; +"65 basenet.4.1.bias" [id=65, type=nncf_model_const]; +"66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[1]/batch_norm_0" [id=66, type=batch_norm]; +"67 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/relu__0" [id=67, type=relu_]; +"68 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; +"69 basenet.4.3.weight" [id=69, type=nncf_model_const]; +"70 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/conv2d_0" [id=71, type=conv2d]; +"72 basenet.4.4.weight" [id=72, type=nncf_model_const]; +"73 basenet.4.4.bias" [id=73, type=nncf_model_const]; +"74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[4]/batch_norm_0" [id=74, type=batch_norm]; +"75 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/relu__0" [id=75, type=relu_]; +"76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; +"77 basenet.5.0.weight" [id=77, type=nncf_model_const]; +"78 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=78, type=symmetric_quantize]; +"79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/conv2d_0" [id=79, type=conv2d]; +"80 basenet.5.1.weight" [id=80, type=nncf_model_const]; +"81 basenet.5.1.bias" [id=81, type=nncf_model_const]; +"82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[1]/batch_norm_0" [id=82, type=batch_norm]; +"83 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/relu__0" [id=83, type=relu_]; +"84 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 basenet.5.3.weight" [id=85, type=nncf_model_const]; +"86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/conv2d_0" [id=87, type=conv2d]; +"88 basenet.5.4.weight" [id=88, type=nncf_model_const]; +"89 basenet.5.4.bias" [id=89, type=nncf_model_const]; +"90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[4]/batch_norm_0" [id=90, type=batch_norm]; +"91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/relu__0" [id=91, type=relu_]; +"92 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=92, type=symmetric_quantize]; +"93 basenet.6.0.weight" [id=93, type=nncf_model_const]; +"94 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/conv2d_0" [id=95, type=conv2d]; +"96 basenet.6.1.weight" [id=96, type=nncf_model_const]; +"97 basenet.6.1.bias" [id=97, type=nncf_model_const]; +"98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[1]/batch_norm_0" [id=98, type=batch_norm]; +"99 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/relu__0" [id=99, type=relu_]; +"100 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; +"101 basenet.6.3.weight" [id=101, type=nncf_model_const]; +"102 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=102, type=symmetric_quantize]; +"103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/conv2d_0" [id=103, type=conv2d]; +"104 basenet.6.4.weight" [id=104, type=nncf_model_const]; +"105 basenet.6.4.bias" [id=105, type=nncf_model_const]; +"106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[4]/batch_norm_0" [id=106, type=batch_norm]; +"107 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/relu__0" [id=107, type=relu_]; +"108 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=108, type=symmetric_quantize]; +"109 basenet.7.0.weight" [id=109, type=nncf_model_const]; +"110 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/conv2d_0" [id=111, type=conv2d]; +"112 basenet.7.1.weight" [id=112, type=nncf_model_const]; +"113 basenet.7.1.bias" [id=113, type=nncf_model_const]; +"114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[1]/batch_norm_0" [id=114, type=batch_norm]; +"115 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/relu__0" [id=115, type=relu_]; +"116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 basenet.7.3.weight" [id=117, type=nncf_model_const]; +"118 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=118, type=symmetric_quantize]; +"119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/conv2d_0" [id=119, type=conv2d]; +"120 basenet.7.4.weight" [id=120, type=nncf_model_const]; +"121 basenet.7.4.bias" [id=121, type=nncf_model_const]; +"122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[4]/batch_norm_0" [id=122, type=batch_norm]; +"123 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/relu__0" [id=123, type=relu_]; +"124 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=124, type=symmetric_quantize]; +"125 basenet.8.0.weight" [id=125, type=nncf_model_const]; +"126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; +"127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/conv2d_0" [id=127, type=conv2d]; +"128 basenet.8.1.weight" [id=128, type=nncf_model_const]; +"129 basenet.8.1.bias" [id=129, type=nncf_model_const]; +"130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[1]/batch_norm_0" [id=130, type=batch_norm]; +"131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/relu__0" [id=131, type=relu_]; +"132 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=132, type=symmetric_quantize]; +"133 basenet.8.3.weight" [id=133, type=nncf_model_const]; +"134 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=134, type=symmetric_quantize]; +"135 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/conv2d_0" [id=135, type=conv2d]; +"136 basenet.8.4.weight" [id=136, type=nncf_model_const]; +"137 basenet.8.4.bias" [id=137, type=nncf_model_const]; +"138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[4]/batch_norm_0" [id=138, type=batch_norm]; +"139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/relu__0" [id=139, type=relu_]; +"140 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 basenet.9.0.weight" [id=141, type=nncf_model_const]; +"142 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=142, type=symmetric_quantize]; +"143 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/conv2d_0" [id=143, type=conv2d]; +"144 basenet.9.1.weight" [id=144, type=nncf_model_const]; +"145 basenet.9.1.bias" [id=145, type=nncf_model_const]; +"146 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[1]/batch_norm_0" [id=146, type=batch_norm]; +"147 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/relu__0" [id=147, type=relu_]; +"148 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=148, type=symmetric_quantize]; +"149 basenet.9.3.weight" [id=149, type=nncf_model_const]; +"150 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=150, type=symmetric_quantize]; +"151 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/conv2d_0" [id=151, type=conv2d]; +"152 basenet.9.4.weight" [id=152, type=nncf_model_const]; +"153 basenet.9.4.bias" [id=153, type=nncf_model_const]; +"154 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[4]/batch_norm_0" [id=154, type=batch_norm]; +"155 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/relu__0" [id=155, type=relu_]; +"156 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 basenet.10.0.weight" [id=157, type=nncf_model_const]; +"158 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=158, type=symmetric_quantize]; +"159 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/conv2d_0" [id=159, type=conv2d]; +"160 basenet.10.1.weight" [id=160, type=nncf_model_const]; +"161 basenet.10.1.bias" [id=161, type=nncf_model_const]; +"162 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[1]/batch_norm_0" [id=162, type=batch_norm]; +"163 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/relu__0" [id=163, type=relu_]; +"164 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=164, type=symmetric_quantize]; +"165 basenet.10.3.weight" [id=165, type=nncf_model_const]; +"166 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=166, type=symmetric_quantize]; +"167 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/conv2d_0" [id=167, type=conv2d]; +"168 basenet.10.4.weight" [id=168, type=nncf_model_const]; +"169 basenet.10.4.bias" [id=169, type=nncf_model_const]; +"170 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[4]/batch_norm_0" [id=170, type=batch_norm]; +"171 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/relu__0" [id=171, type=relu_]; +"172 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=172, type=symmetric_quantize]; +"173 basenet.11.0.weight" [id=173, type=nncf_model_const]; +"174 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=174, type=symmetric_quantize]; +"175 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/conv2d_0" [id=175, type=conv2d]; +"176 basenet.11.1.weight" [id=176, type=nncf_model_const]; +"177 basenet.11.1.bias" [id=177, type=nncf_model_const]; +"178 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[1]/batch_norm_0" [id=178, type=batch_norm]; +"179 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/relu__0" [id=179, type=relu_]; +"180 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=180, type=symmetric_quantize]; +"181 basenet.11.3.weight" [id=181, type=nncf_model_const]; +"182 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/conv2d_0" [id=183, type=conv2d]; +"184 basenet.11.4.weight" [id=184, type=nncf_model_const]; +"185 basenet.11.4.bias" [id=185, type=nncf_model_const]; +"186 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[4]/batch_norm_0" [id=186, type=batch_norm]; +"187 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/relu__0" [id=187, type=relu_]; +"188 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; +"189 basenet.12.0.weight" [id=189, type=nncf_model_const]; +"190 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=190, type=symmetric_quantize]; +"191 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/conv2d_0" [id=191, type=conv2d]; +"192 basenet.12.1.weight" [id=192, type=nncf_model_const]; +"193 basenet.12.1.bias" [id=193, type=nncf_model_const]; +"194 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[1]/batch_norm_0" [id=194, type=batch_norm]; +"195 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/relu__0" [id=195, type=relu_]; +"196 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=196, type=symmetric_quantize]; +"197 basenet.12.3.weight" [id=197, type=nncf_model_const]; +"198 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; +"199 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/conv2d_0" [id=199, type=conv2d]; +"200 basenet.12.4.weight" [id=200, type=nncf_model_const]; +"201 basenet.12.4.bias" [id=201, type=nncf_model_const]; +"202 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[4]/batch_norm_0" [id=202, type=batch_norm]; +"203 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/relu__0" [id=203, type=relu_]; +"204 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=204, type=symmetric_quantize]; +"205 basenet.13.0.weight" [id=205, type=nncf_model_const]; +"206 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=206, type=symmetric_quantize]; +"207 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/conv2d_0" [id=207, type=conv2d]; +"208 basenet.13.1.weight" [id=208, type=nncf_model_const]; +"209 basenet.13.1.bias" [id=209, type=nncf_model_const]; +"210 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[1]/batch_norm_0" [id=210, type=batch_norm]; +"211 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/relu__0" [id=211, type=relu_]; +"212 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=212, type=symmetric_quantize]; +"213 basenet.13.3.weight" [id=213, type=nncf_model_const]; +"214 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=214, type=symmetric_quantize]; +"215 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/conv2d_0" [id=215, type=conv2d]; +"216 basenet.13.4.weight" [id=216, type=nncf_model_const]; +"217 basenet.13.4.bias" [id=217, type=nncf_model_const]; +"218 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[4]/batch_norm_0" [id=218, type=batch_norm]; +"219 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/relu__0" [id=219, type=relu_]; +"220 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=220, type=symmetric_quantize]; +"221 extras.0.0.weight" [id=221, type=nncf_model_const]; +"222 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=222, type=symmetric_quantize]; +"223 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/conv2d_0" [id=223, type=conv2d]; +"224 extras.0.1.weight" [id=224, type=nncf_model_const]; +"225 extras.0.1.bias" [id=225, type=nncf_model_const]; +"226 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/BatchNorm2d[1]/batch_norm_0" [id=226, type=batch_norm]; +"227 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/relu__0" [id=227, type=relu_]; +"228 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 extras.1.0.weight" [id=229, type=nncf_model_const]; +"230 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=230, type=symmetric_quantize]; +"231 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/conv2d_0" [id=231, type=conv2d]; +"232 extras.1.1.weight" [id=232, type=nncf_model_const]; +"233 extras.1.1.bias" [id=233, type=nncf_model_const]; +"234 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/BatchNorm2d[1]/batch_norm_0" [id=234, type=batch_norm]; +"235 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/relu__0" [id=235, type=relu_]; +"236 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=236, type=symmetric_quantize]; +"237 extras.2.0.weight" [id=237, type=nncf_model_const]; +"238 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=238, type=symmetric_quantize]; +"239 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/conv2d_0" [id=239, type=conv2d]; +"240 extras.2.1.weight" [id=240, type=nncf_model_const]; +"241 extras.2.1.bias" [id=241, type=nncf_model_const]; +"242 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/BatchNorm2d[1]/batch_norm_0" [id=242, type=batch_norm]; +"243 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/relu__0" [id=243, type=relu_]; +"244 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; +"245 extras.3.0.weight" [id=245, type=nncf_model_const]; +"246 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=246, type=symmetric_quantize]; +"247 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/conv2d_0" [id=247, type=conv2d]; +"248 extras.3.1.weight" [id=248, type=nncf_model_const]; +"249 extras.3.1.bias" [id=249, type=nncf_model_const]; +"250 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/BatchNorm2d[1]/batch_norm_0" [id=250, type=batch_norm]; +"251 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/relu__0" [id=251, type=relu_]; +"252 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=252, type=symmetric_quantize]; +"253 extras.4.0.weight" [id=253, type=nncf_model_const]; +"254 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=254, type=symmetric_quantize]; +"255 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/conv2d_0" [id=255, type=conv2d]; +"256 extras.4.1.weight" [id=256, type=nncf_model_const]; +"257 extras.4.1.bias" [id=257, type=nncf_model_const]; +"258 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/BatchNorm2d[1]/batch_norm_0" [id=258, type=batch_norm]; +"259 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/relu__0" [id=259, type=relu_]; +"260 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=260, type=symmetric_quantize]; +"261 extras.5.0.weight" [id=261, type=nncf_model_const]; +"262 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=262, type=symmetric_quantize]; +"263 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/conv2d_0" [id=263, type=conv2d]; +"264 extras.5.1.weight" [id=264, type=nncf_model_const]; +"265 extras.5.1.bias" [id=265, type=nncf_model_const]; +"266 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/BatchNorm2d[1]/batch_norm_0" [id=266, type=batch_norm]; +"267 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/relu__0" [id=267, type=relu_]; +"268 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=268, type=symmetric_quantize]; +"269 extras.6.0.weight" [id=269, type=nncf_model_const]; +"270 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=270, type=symmetric_quantize]; +"271 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/conv2d_0" [id=271, type=conv2d]; +"272 extras.6.1.weight" [id=272, type=nncf_model_const]; +"273 extras.6.1.bias" [id=273, type=nncf_model_const]; +"274 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/BatchNorm2d[1]/batch_norm_0" [id=274, type=batch_norm]; +"275 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/relu__0" [id=275, type=relu_]; +"276 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=276, type=symmetric_quantize]; +"277 extras.7.0.weight" [id=277, type=nncf_model_const]; +"278 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=278, type=symmetric_quantize]; +"279 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/conv2d_0" [id=279, type=conv2d]; +"280 extras.7.1.weight" [id=280, type=nncf_model_const]; +"281 extras.7.1.bias" [id=281, type=nncf_model_const]; +"282 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/BatchNorm2d[1]/batch_norm_0" [id=282, type=batch_norm]; +"283 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/relu__0" [id=283, type=relu_]; +"284 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 detection_head.heads.0.loc.weight" [id=285, type=nncf_model_const]; +"286 detection_head.heads.0.loc.bias" [id=286, type=nncf_model_const]; +"287 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=287, type=symmetric_quantize]; +"288 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0" [id=288, type=conv2d]; +"289 detection_head.heads.0.conf.weight" [id=289, type=nncf_model_const]; +"290 detection_head.heads.0.conf.bias" [id=290, type=nncf_model_const]; +"291 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=291, type=symmetric_quantize]; +"292 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0" [id=292, type=conv2d]; +"293 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" [id=293, type=permute]; +"294 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" [id=294, type=contiguous]; +"295 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" [id=295, type=permute]; +"296 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" [id=296, type=contiguous]; +"297 detection_head.heads.1.loc.weight" [id=297, type=nncf_model_const]; +"298 detection_head.heads.1.loc.bias" [id=298, type=nncf_model_const]; +"299 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=299, type=symmetric_quantize]; +"300 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0" [id=300, type=conv2d]; +"301 detection_head.heads.1.conf.weight" [id=301, type=nncf_model_const]; +"302 detection_head.heads.1.conf.bias" [id=302, type=nncf_model_const]; +"303 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=303, type=symmetric_quantize]; +"304 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0" [id=304, type=conv2d]; +"305 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" [id=305, type=permute]; +"306 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" [id=306, type=contiguous]; +"307 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" [id=307, type=permute]; +"308 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" [id=308, type=contiguous]; +"309 detection_head.heads.2.loc.weight" [id=309, type=nncf_model_const]; +"310 detection_head.heads.2.loc.bias" [id=310, type=nncf_model_const]; +"311 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=311, type=symmetric_quantize]; +"312 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0" [id=312, type=conv2d]; +"313 detection_head.heads.2.conf.weight" [id=313, type=nncf_model_const]; +"314 detection_head.heads.2.conf.bias" [id=314, type=nncf_model_const]; +"315 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=315, type=symmetric_quantize]; +"316 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0" [id=316, type=conv2d]; +"317 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" [id=317, type=permute]; +"318 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" [id=318, type=contiguous]; +"319 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" [id=319, type=permute]; +"320 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" [id=320, type=contiguous]; +"321 detection_head.heads.3.loc.weight" [id=321, type=nncf_model_const]; +"322 detection_head.heads.3.loc.bias" [id=322, type=nncf_model_const]; +"323 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=323, type=symmetric_quantize]; +"324 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0" [id=324, type=conv2d]; +"325 detection_head.heads.3.conf.weight" [id=325, type=nncf_model_const]; +"326 detection_head.heads.3.conf.bias" [id=326, type=nncf_model_const]; +"327 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=327, type=symmetric_quantize]; +"328 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0" [id=328, type=conv2d]; +"329 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" [id=329, type=permute]; +"330 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" [id=330, type=contiguous]; +"331 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" [id=331, type=permute]; +"332 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" [id=332, type=contiguous]; +"333 detection_head.heads.4.loc.weight" [id=333, type=nncf_model_const]; +"334 detection_head.heads.4.loc.bias" [id=334, type=nncf_model_const]; +"335 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0" [id=336, type=conv2d]; +"337 detection_head.heads.4.conf.weight" [id=337, type=nncf_model_const]; +"338 detection_head.heads.4.conf.bias" [id=338, type=nncf_model_const]; +"339 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=339, type=symmetric_quantize]; +"340 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0" [id=340, type=conv2d]; +"341 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" [id=341, type=permute]; +"342 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" [id=342, type=contiguous]; +"343 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" [id=343, type=permute]; +"344 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" [id=344, type=contiguous]; +"345 detection_head.heads.5.loc.weight" [id=345, type=nncf_model_const]; +"346 detection_head.heads.5.loc.bias" [id=346, type=nncf_model_const]; +"347 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=347, type=symmetric_quantize]; +"348 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0" [id=348, type=conv2d]; +"349 detection_head.heads.5.conf.weight" [id=349, type=nncf_model_const]; +"350 detection_head.heads.5.conf.bias" [id=350, type=nncf_model_const]; +"351 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=351, type=symmetric_quantize]; +"352 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0" [id=352, type=conv2d]; +"353 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" [id=353, type=permute]; +"354 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" [id=354, type=contiguous]; +"355 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" [id=355, type=permute]; +"356 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" [id=356, type=contiguous]; +"357 MobileNetSSD/SSDDetectionOutput[detection_head]/view_0" [id=357, type=view]; +"358 MobileNetSSD/SSDDetectionOutput[detection_head]/view_1" [id=358, type=view]; +"359 MobileNetSSD/SSDDetectionOutput[detection_head]/view_2" [id=359, type=view]; +"360 MobileNetSSD/SSDDetectionOutput[detection_head]/view_3" [id=360, type=view]; +"361 MobileNetSSD/SSDDetectionOutput[detection_head]/view_4" [id=361, type=view]; +"362 MobileNetSSD/SSDDetectionOutput[detection_head]/view_5" [id=362, type=view]; +"363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0" [id=363, type=cat]; +"364 MobileNetSSD/SSDDetectionOutput[detection_head]/view_6" [id=364, type=view]; +"365 MobileNetSSD/SSDDetectionOutput[detection_head]/view_7" [id=365, type=view]; +"366 MobileNetSSD/SSDDetectionOutput[detection_head]/view_8" [id=366, type=view]; +"367 MobileNetSSD/SSDDetectionOutput[detection_head]/view_9" [id=367, type=view]; +"368 MobileNetSSD/SSDDetectionOutput[detection_head]/view_10" [id=368, type=view]; +"369 MobileNetSSD/SSDDetectionOutput[detection_head]/view_11" [id=369, type=view]; +"370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1" [id=370, type=cat]; +"371 MobileNetSSD/SSDDetectionOutput[detection_head]/view_12" [id=371, type=view]; +"372 MobileNetSSD/SSDDetectionOutput[detection_head]/softmax_0" [id=372, type=softmax]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; "1 SymmetricQuantizer/symmetric_quantize_0" -> "2 MobileNetSSD/__getitem___0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/conv2d_0"; "2 MobileNetSSD/__getitem___0" -> "3 MobileNetSSD/clone_0"; "3 MobileNetSSD/clone_0" -> "4 MobileNetSSD/unsqueeze_0"; -"5 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; -"6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFConv2d[0]/conv2d_0" -> "7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "8 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/relu__0"; -"8 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/relu__0" -> "9 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"9 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; -"10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; -"11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[0]/conv2d_0" -> "12 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"12 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "13 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/relu__0"; -"13 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/relu__0" -> "14 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"14 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "16 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[3]/conv2d_0"; -"15 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "16 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[3]/conv2d_0"; -"16 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFConv2d[3]/conv2d_0" -> "17 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFBatchNorm2d[4]/batch_norm_0"; -"17 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/NNCFBatchNorm2d[4]/batch_norm_0" -> "18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/relu__0"; -"18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/relu__0" -> "19 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"19 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "21 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[0]/conv2d_0"; -"20 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[0]/conv2d_0"; -"21 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[0]/conv2d_0" -> "22 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"22 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/relu__0"; -"23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/relu__0" -> "24 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"24 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[3]/conv2d_0"; -"25 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[3]/conv2d_0"; -"26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFConv2d[3]/conv2d_0" -> "27 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFBatchNorm2d[4]/batch_norm_0"; -"27 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/NNCFBatchNorm2d[4]/batch_norm_0" -> "28 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/relu__0"; -"28 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/relu__0" -> "29 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"29 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[0]/conv2d_0"; -"30 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[0]/conv2d_0"; -"31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[0]/conv2d_0" -> "32 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"32 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "33 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/relu__0"; -"33 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/relu__0" -> "34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[3]/conv2d_0"; -"35 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[3]/conv2d_0"; -"36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFConv2d[3]/conv2d_0" -> "37 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFBatchNorm2d[4]/batch_norm_0"; -"37 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/NNCFBatchNorm2d[4]/batch_norm_0" -> "38 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/relu__0"; -"38 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/relu__0" -> "39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "41 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[0]/conv2d_0"; -"40 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "41 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[0]/conv2d_0"; -"41 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[0]/conv2d_0" -> "42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFBatchNorm2d[1]/batch_norm_0"; -"42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFBatchNorm2d[1]/batch_norm_0" -> "43 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/relu__0"; -"43 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/relu__0" -> "44 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"44 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[3]/conv2d_0"; -"45 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[3]/conv2d_0"; -"46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFConv2d[3]/conv2d_0" -> "47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFBatchNorm2d[4]/batch_norm_0"; -"47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/NNCFBatchNorm2d[4]/batch_norm_0" -> "48 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/relu__0"; -"48 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/relu__0" -> "49 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"49 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[0]/conv2d_0"; -"50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[0]/conv2d_0"; -"51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[0]/conv2d_0" -> "52 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFBatchNorm2d[1]/batch_norm_0"; -"52 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFBatchNorm2d[1]/batch_norm_0" -> "53 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/relu__0"; -"53 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/relu__0" -> "54 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"54 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "56 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[3]/conv2d_0"; -"55 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "56 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[3]/conv2d_0"; -"56 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFConv2d[3]/conv2d_0" -> "57 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFBatchNorm2d[4]/batch_norm_0"; -"57 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/NNCFBatchNorm2d[4]/batch_norm_0" -> "58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/relu__0"; -"58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/relu__0" -> "59 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"59 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "61 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[0]/conv2d_0"; -"60 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "61 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[0]/conv2d_0"; -"61 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[0]/conv2d_0" -> "62 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFBatchNorm2d[1]/batch_norm_0"; -"62 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFBatchNorm2d[1]/batch_norm_0" -> "63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/relu__0"; -"63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/relu__0" -> "64 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"64 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[3]/conv2d_0"; -"65 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[3]/conv2d_0"; -"66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFConv2d[3]/conv2d_0" -> "67 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFBatchNorm2d[4]/batch_norm_0"; -"67 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/NNCFBatchNorm2d[4]/batch_norm_0" -> "68 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/relu__0"; -"68 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/relu__0" -> "69 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"69 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[0]/conv2d_0"; -"70 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[0]/conv2d_0"; -"71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[0]/conv2d_0" -> "72 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFBatchNorm2d[1]/batch_norm_0"; -"72 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFBatchNorm2d[1]/batch_norm_0" -> "73 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/relu__0"; -"73 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/relu__0" -> "74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[3]/conv2d_0"; -"75 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[3]/conv2d_0"; -"76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFConv2d[3]/conv2d_0" -> "77 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFBatchNorm2d[4]/batch_norm_0"; -"77 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/NNCFBatchNorm2d[4]/batch_norm_0" -> "78 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/relu__0"; -"78 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/relu__0" -> "79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "81 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[0]/conv2d_0"; -"80 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "81 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[0]/conv2d_0"; -"81 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[0]/conv2d_0" -> "82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFBatchNorm2d[1]/batch_norm_0"; -"82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFBatchNorm2d[1]/batch_norm_0" -> "83 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/relu__0"; -"83 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/relu__0" -> "84 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"84 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[3]/conv2d_0"; -"85 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[3]/conv2d_0"; -"86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFConv2d[3]/conv2d_0" -> "87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFBatchNorm2d[4]/batch_norm_0"; -"87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/NNCFBatchNorm2d[4]/batch_norm_0" -> "88 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/relu__0"; -"88 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/relu__0" -> "89 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"89 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[0]/conv2d_0"; -"90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[0]/conv2d_0"; -"91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[0]/conv2d_0" -> "92 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFBatchNorm2d[1]/batch_norm_0"; -"92 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFBatchNorm2d[1]/batch_norm_0" -> "93 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/relu__0"; -"93 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/relu__0" -> "94 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"94 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "96 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[3]/conv2d_0"; -"95 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "96 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[3]/conv2d_0"; -"96 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFConv2d[3]/conv2d_0" -> "97 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFBatchNorm2d[4]/batch_norm_0"; -"97 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/NNCFBatchNorm2d[4]/batch_norm_0" -> "98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/relu__0"; -"98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/relu__0" -> "99 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"99 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "101 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[0]/conv2d_0"; -"100 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "101 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[0]/conv2d_0"; -"101 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[0]/conv2d_0" -> "102 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFBatchNorm2d[1]/batch_norm_0"; -"102 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFBatchNorm2d[1]/batch_norm_0" -> "103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/relu__0"; -"103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/relu__0" -> "104 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"104 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[3]/conv2d_0"; -"105 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[3]/conv2d_0"; -"106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFConv2d[3]/conv2d_0" -> "107 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFBatchNorm2d[4]/batch_norm_0"; -"107 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/NNCFBatchNorm2d[4]/batch_norm_0" -> "108 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/relu__0"; -"108 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/relu__0" -> "109 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"109 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[0]/conv2d_0"; -"110 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[0]/conv2d_0"; -"111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[0]/conv2d_0" -> "112 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFBatchNorm2d[1]/batch_norm_0"; -"112 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFBatchNorm2d[1]/batch_norm_0" -> "113 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/relu__0"; -"113 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/relu__0" -> "114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[3]/conv2d_0"; -"115 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[3]/conv2d_0"; -"116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFConv2d[3]/conv2d_0" -> "117 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFBatchNorm2d[4]/batch_norm_0"; -"117 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/NNCFBatchNorm2d[4]/batch_norm_0" -> "118 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/relu__0"; -"118 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/relu__0" -> "119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "121 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[0]/conv2d_0"; -"119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "181 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0"; -"119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "183 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0"; -"120 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "121 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[0]/conv2d_0"; -"121 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[0]/conv2d_0" -> "122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFBatchNorm2d[1]/batch_norm_0"; -"122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFBatchNorm2d[1]/batch_norm_0" -> "123 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/relu__0"; -"123 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/relu__0" -> "124 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"124 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[3]/conv2d_0"; -"125 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[3]/conv2d_0"; -"126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFConv2d[3]/conv2d_0" -> "127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFBatchNorm2d[4]/batch_norm_0"; -"127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/NNCFBatchNorm2d[4]/batch_norm_0" -> "128 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/relu__0"; -"128 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/relu__0" -> "129 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"129 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[0]/conv2d_0"; -"130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[0]/conv2d_0"; -"131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[0]/conv2d_0" -> "132 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFBatchNorm2d[1]/batch_norm_0"; -"132 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFBatchNorm2d[1]/batch_norm_0" -> "133 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/relu__0"; -"133 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/relu__0" -> "134 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"134 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "136 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[3]/conv2d_0"; -"135 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "136 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[3]/conv2d_0"; -"136 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFConv2d[3]/conv2d_0" -> "137 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFBatchNorm2d[4]/batch_norm_0"; -"137 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/NNCFBatchNorm2d[4]/batch_norm_0" -> "138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/relu__0"; -"138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/relu__0" -> "139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "141 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; -"139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "189 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0"; -"139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "191 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0"; -"140 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "141 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFConv2d[0]/conv2d_0"; -"141 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFConv2d[0]/conv2d_0" -> "142 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFBatchNorm2d[1]/batch_norm_0"; -"142 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/NNCFBatchNorm2d[1]/batch_norm_0" -> "143 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/relu__0"; -"143 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/relu__0" -> "144 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"144 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "146 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; -"145 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "146 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFConv2d[0]/conv2d_0"; -"146 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFConv2d[0]/conv2d_0" -> "147 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFBatchNorm2d[1]/batch_norm_0"; -"147 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/NNCFBatchNorm2d[1]/batch_norm_0" -> "148 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/relu__0"; -"148 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/relu__0" -> "149 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"149 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "151 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFConv2d[0]/conv2d_0"; -"149 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "197 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0"; -"149 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "199 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0"; -"150 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "151 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFConv2d[0]/conv2d_0"; -"151 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFConv2d[0]/conv2d_0" -> "152 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFBatchNorm2d[1]/batch_norm_0"; -"152 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/NNCFBatchNorm2d[1]/batch_norm_0" -> "153 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/relu__0"; -"153 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/relu__0" -> "154 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"154 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "156 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFConv2d[0]/conv2d_0"; -"155 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "156 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFConv2d[0]/conv2d_0"; -"156 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFConv2d[0]/conv2d_0" -> "157 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFBatchNorm2d[1]/batch_norm_0"; -"157 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/NNCFBatchNorm2d[1]/batch_norm_0" -> "158 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/relu__0"; -"158 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/relu__0" -> "159 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"159 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "161 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFConv2d[0]/conv2d_0"; -"159 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "205 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0"; -"159 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "207 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0"; -"160 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "161 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFConv2d[0]/conv2d_0"; -"161 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFConv2d[0]/conv2d_0" -> "162 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFBatchNorm2d[1]/batch_norm_0"; -"162 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/NNCFBatchNorm2d[1]/batch_norm_0" -> "163 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/relu__0"; -"163 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/relu__0" -> "164 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"164 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "166 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFConv2d[0]/conv2d_0"; -"165 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "166 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFConv2d[0]/conv2d_0"; -"166 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFConv2d[0]/conv2d_0" -> "167 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFBatchNorm2d[1]/batch_norm_0"; -"167 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/NNCFBatchNorm2d[1]/batch_norm_0" -> "168 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/relu__0"; -"168 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/relu__0" -> "169 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"169 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "171 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFConv2d[0]/conv2d_0"; -"169 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "213 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0"; -"169 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "215 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0"; -"170 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "171 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFConv2d[0]/conv2d_0"; -"171 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFConv2d[0]/conv2d_0" -> "172 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFBatchNorm2d[1]/batch_norm_0"; -"172 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/NNCFBatchNorm2d[1]/batch_norm_0" -> "173 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/relu__0"; -"173 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/relu__0" -> "174 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"174 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "176 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFConv2d[0]/conv2d_0"; -"175 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "176 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFConv2d[0]/conv2d_0"; -"176 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFConv2d[0]/conv2d_0" -> "177 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFBatchNorm2d[1]/batch_norm_0"; -"177 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/NNCFBatchNorm2d[1]/batch_norm_0" -> "178 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/relu__0"; -"178 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/relu__0" -> "179 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"179 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "221 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0"; -"179 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "223 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0"; -"180 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "181 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0"; -"181 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0" -> "184 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0"; -"182 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "183 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0"; -"183 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0" -> "186 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1"; -"184 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" -> "185 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0"; -"185 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" -> "228 MobileNetSSD/SSDDetectionOutput[detection_head]/view_0"; -"186 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" -> "187 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1"; -"187 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" -> "235 MobileNetSSD/SSDDetectionOutput[detection_head]/view_6"; -"188 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "189 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0"; -"189 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0" -> "192 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0"; -"190 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "191 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0"; -"191 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0" -> "194 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1"; -"192 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" -> "193 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0"; -"193 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" -> "229 MobileNetSSD/SSDDetectionOutput[detection_head]/view_1"; -"194 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" -> "195 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1"; -"195 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" -> "236 MobileNetSSD/SSDDetectionOutput[detection_head]/view_7"; -"196 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "197 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0"; -"197 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0" -> "200 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0"; -"198 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "199 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0"; -"199 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0" -> "202 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1"; -"200 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" -> "201 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0"; -"201 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" -> "230 MobileNetSSD/SSDDetectionOutput[detection_head]/view_2"; -"202 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" -> "203 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1"; -"203 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" -> "237 MobileNetSSD/SSDDetectionOutput[detection_head]/view_8"; -"204 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "205 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0"; -"205 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0" -> "208 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0"; -"206 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "207 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0"; -"207 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0" -> "210 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1"; -"208 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" -> "209 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0"; -"209 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" -> "231 MobileNetSSD/SSDDetectionOutput[detection_head]/view_3"; -"210 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" -> "211 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1"; -"211 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" -> "238 MobileNetSSD/SSDDetectionOutput[detection_head]/view_9"; -"212 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "213 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0"; -"213 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0" -> "216 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0"; -"214 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "215 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0"; -"215 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0" -> "218 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1"; -"216 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" -> "217 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0"; -"217 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" -> "232 MobileNetSSD/SSDDetectionOutput[detection_head]/view_4"; -"218 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" -> "219 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1"; -"219 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" -> "239 MobileNetSSD/SSDDetectionOutput[detection_head]/view_10"; -"220 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "221 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0"; -"221 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0" -> "224 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0"; -"222 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "223 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0"; -"223 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0" -> "226 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1"; -"224 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" -> "225 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0"; -"225 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" -> "233 MobileNetSSD/SSDDetectionOutput[detection_head]/view_5"; -"226 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" -> "227 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1"; -"227 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" -> "240 MobileNetSSD/SSDDetectionOutput[detection_head]/view_11"; -"228 MobileNetSSD/SSDDetectionOutput[detection_head]/view_0" -> "234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; -"229 MobileNetSSD/SSDDetectionOutput[detection_head]/view_1" -> "234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; -"230 MobileNetSSD/SSDDetectionOutput[detection_head]/view_2" -> "234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; -"231 MobileNetSSD/SSDDetectionOutput[detection_head]/view_3" -> "234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; -"232 MobileNetSSD/SSDDetectionOutput[detection_head]/view_4" -> "234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; -"233 MobileNetSSD/SSDDetectionOutput[detection_head]/view_5" -> "234 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; -"235 MobileNetSSD/SSDDetectionOutput[detection_head]/view_6" -> "241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; -"236 MobileNetSSD/SSDDetectionOutput[detection_head]/view_7" -> "241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; -"237 MobileNetSSD/SSDDetectionOutput[detection_head]/view_8" -> "241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; -"238 MobileNetSSD/SSDDetectionOutput[detection_head]/view_9" -> "241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; -"239 MobileNetSSD/SSDDetectionOutput[detection_head]/view_10" -> "241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; -"240 MobileNetSSD/SSDDetectionOutput[detection_head]/view_11" -> "241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; -"241 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1" -> "242 MobileNetSSD/SSDDetectionOutput[detection_head]/view_12"; -"242 MobileNetSSD/SSDDetectionOutput[detection_head]/view_12" -> "243 MobileNetSSD/SSDDetectionOutput[detection_head]/softmax_0"; +"5 basenet.0.0.weight" -> "6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"6 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/conv2d_0"; +"7 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/Conv2d[0]/conv2d_0" -> "10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/BatchNorm2d[1]/batch_norm_0"; +"8 basenet.0.1.weight" -> "10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/BatchNorm2d[1]/batch_norm_0"; +"9 basenet.0.1.bias" -> "10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/BatchNorm2d[1]/batch_norm_0"; +"10 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/BatchNorm2d[1]/batch_norm_0" -> "11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/relu__0"; +"11 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/relu__0" -> "12 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"12 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "15 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/conv2d_0"; +"13 basenet.1.0.weight" -> "14 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"14 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "15 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/conv2d_0"; +"15 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[0]/conv2d_0" -> "18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[1]/batch_norm_0"; +"16 basenet.1.1.weight" -> "18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[1]/batch_norm_0"; +"17 basenet.1.1.bias" -> "18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[1]/batch_norm_0"; +"18 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[1]/batch_norm_0" -> "19 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/relu__0"; +"19 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/relu__0" -> "20 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"20 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/conv2d_0"; +"21 basenet.1.3.weight" -> "22 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"22 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/conv2d_0"; +"23 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/Conv2d[3]/conv2d_0" -> "26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[4]/batch_norm_0"; +"24 basenet.1.4.weight" -> "26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[4]/batch_norm_0"; +"25 basenet.1.4.bias" -> "26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[4]/batch_norm_0"; +"26 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/BatchNorm2d[4]/batch_norm_0" -> "27 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/relu__0"; +"27 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/relu__0" -> "28 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"28 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[1]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/conv2d_0"; +"29 basenet.2.0.weight" -> "30 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"30 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/conv2d_0"; +"31 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[0]/conv2d_0" -> "34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[1]/batch_norm_0"; +"32 basenet.2.1.weight" -> "34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[1]/batch_norm_0"; +"33 basenet.2.1.bias" -> "34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[1]/batch_norm_0"; +"34 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[1]/batch_norm_0" -> "35 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/relu__0"; +"35 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/relu__0" -> "36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"36 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/conv2d_0"; +"37 basenet.2.3.weight" -> "38 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"38 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/conv2d_0"; +"39 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/Conv2d[3]/conv2d_0" -> "42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[4]/batch_norm_0"; +"40 basenet.2.4.weight" -> "42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[4]/batch_norm_0"; +"41 basenet.2.4.bias" -> "42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[4]/batch_norm_0"; +"42 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/BatchNorm2d[4]/batch_norm_0" -> "43 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/relu__0"; +"43 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/relu__0" -> "44 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"44 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[2]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/conv2d_0"; +"45 basenet.3.0.weight" -> "46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"46 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/conv2d_0"; +"47 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[0]/conv2d_0" -> "50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[1]/batch_norm_0"; +"48 basenet.3.1.weight" -> "50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[1]/batch_norm_0"; +"49 basenet.3.1.bias" -> "50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[1]/batch_norm_0"; +"50 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[1]/batch_norm_0" -> "51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/relu__0"; +"51 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/relu__0" -> "52 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"52 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "55 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/conv2d_0"; +"53 basenet.3.3.weight" -> "54 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"54 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "55 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/conv2d_0"; +"55 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/Conv2d[3]/conv2d_0" -> "58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[4]/batch_norm_0"; +"56 basenet.3.4.weight" -> "58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[4]/batch_norm_0"; +"57 basenet.3.4.bias" -> "58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[4]/batch_norm_0"; +"58 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/BatchNorm2d[4]/batch_norm_0" -> "59 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/relu__0"; +"59 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/relu__0" -> "60 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"60 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[3]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/conv2d_0"; +"61 basenet.4.0.weight" -> "62 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"62 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/conv2d_0"; +"63 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[0]/conv2d_0" -> "66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[1]/batch_norm_0"; +"64 basenet.4.1.weight" -> "66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[1]/batch_norm_0"; +"65 basenet.4.1.bias" -> "66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[1]/batch_norm_0"; +"66 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[1]/batch_norm_0" -> "67 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/relu__0"; +"67 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/relu__0" -> "68 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"68 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/conv2d_0"; +"69 basenet.4.3.weight" -> "70 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"70 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/conv2d_0"; +"71 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/Conv2d[3]/conv2d_0" -> "74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[4]/batch_norm_0"; +"72 basenet.4.4.weight" -> "74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[4]/batch_norm_0"; +"73 basenet.4.4.bias" -> "74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[4]/batch_norm_0"; +"74 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/BatchNorm2d[4]/batch_norm_0" -> "75 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/relu__0"; +"75 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/relu__0" -> "76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"76 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[4]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/conv2d_0"; +"77 basenet.5.0.weight" -> "78 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"78 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/conv2d_0"; +"79 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[0]/conv2d_0" -> "82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[1]/batch_norm_0"; +"80 basenet.5.1.weight" -> "82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[1]/batch_norm_0"; +"81 basenet.5.1.bias" -> "82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[1]/batch_norm_0"; +"82 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[1]/batch_norm_0" -> "83 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/relu__0"; +"83 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/relu__0" -> "84 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"84 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/conv2d_0"; +"85 basenet.5.3.weight" -> "86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"86 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/conv2d_0"; +"87 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/Conv2d[3]/conv2d_0" -> "90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[4]/batch_norm_0"; +"88 basenet.5.4.weight" -> "90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[4]/batch_norm_0"; +"89 basenet.5.4.bias" -> "90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[4]/batch_norm_0"; +"90 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/BatchNorm2d[4]/batch_norm_0" -> "91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/relu__0"; +"91 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/relu__0" -> "92 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"92 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[5]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "95 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/conv2d_0"; +"93 basenet.6.0.weight" -> "94 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"94 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "95 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/conv2d_0"; +"95 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[0]/conv2d_0" -> "98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[1]/batch_norm_0"; +"96 basenet.6.1.weight" -> "98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[1]/batch_norm_0"; +"97 basenet.6.1.bias" -> "98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[1]/batch_norm_0"; +"98 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[1]/batch_norm_0" -> "99 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/relu__0"; +"99 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/relu__0" -> "100 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"100 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/conv2d_0"; +"101 basenet.6.3.weight" -> "102 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"102 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/conv2d_0"; +"103 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/Conv2d[3]/conv2d_0" -> "106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[4]/batch_norm_0"; +"104 basenet.6.4.weight" -> "106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[4]/batch_norm_0"; +"105 basenet.6.4.bias" -> "106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[4]/batch_norm_0"; +"106 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/BatchNorm2d[4]/batch_norm_0" -> "107 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/relu__0"; +"107 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/relu__0" -> "108 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"108 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[6]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/conv2d_0"; +"109 basenet.7.0.weight" -> "110 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"110 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/conv2d_0"; +"111 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[0]/conv2d_0" -> "114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[1]/batch_norm_0"; +"112 basenet.7.1.weight" -> "114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[1]/batch_norm_0"; +"113 basenet.7.1.bias" -> "114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[1]/batch_norm_0"; +"114 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[1]/batch_norm_0" -> "115 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/relu__0"; +"115 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/relu__0" -> "116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"116 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/conv2d_0"; +"117 basenet.7.3.weight" -> "118 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"118 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/conv2d_0"; +"119 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/Conv2d[3]/conv2d_0" -> "122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[4]/batch_norm_0"; +"120 basenet.7.4.weight" -> "122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[4]/batch_norm_0"; +"121 basenet.7.4.bias" -> "122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[4]/batch_norm_0"; +"122 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/BatchNorm2d[4]/batch_norm_0" -> "123 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/relu__0"; +"123 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/relu__0" -> "124 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"124 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[7]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/conv2d_0"; +"125 basenet.8.0.weight" -> "126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"126 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/conv2d_0"; +"127 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[0]/conv2d_0" -> "130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[1]/batch_norm_0"; +"128 basenet.8.1.weight" -> "130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[1]/batch_norm_0"; +"129 basenet.8.1.bias" -> "130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[1]/batch_norm_0"; +"130 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[1]/batch_norm_0" -> "131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/relu__0"; +"131 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/relu__0" -> "132 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"132 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "135 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/conv2d_0"; +"133 basenet.8.3.weight" -> "134 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"134 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "135 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/conv2d_0"; +"135 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/Conv2d[3]/conv2d_0" -> "138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[4]/batch_norm_0"; +"136 basenet.8.4.weight" -> "138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[4]/batch_norm_0"; +"137 basenet.8.4.bias" -> "138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[4]/batch_norm_0"; +"138 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/BatchNorm2d[4]/batch_norm_0" -> "139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/relu__0"; +"139 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/relu__0" -> "140 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"140 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[8]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "143 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/conv2d_0"; +"141 basenet.9.0.weight" -> "142 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"142 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "143 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/conv2d_0"; +"143 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[0]/conv2d_0" -> "146 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[1]/batch_norm_0"; +"144 basenet.9.1.weight" -> "146 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[1]/batch_norm_0"; +"145 basenet.9.1.bias" -> "146 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[1]/batch_norm_0"; +"146 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[1]/batch_norm_0" -> "147 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/relu__0"; +"147 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/relu__0" -> "148 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"148 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "151 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/conv2d_0"; +"149 basenet.9.3.weight" -> "150 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"150 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "151 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/conv2d_0"; +"151 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/Conv2d[3]/conv2d_0" -> "154 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[4]/batch_norm_0"; +"152 basenet.9.4.weight" -> "154 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[4]/batch_norm_0"; +"153 basenet.9.4.bias" -> "154 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[4]/batch_norm_0"; +"154 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/BatchNorm2d[4]/batch_norm_0" -> "155 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/relu__0"; +"155 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/relu__0" -> "156 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"156 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[9]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "159 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/conv2d_0"; +"157 basenet.10.0.weight" -> "158 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"158 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "159 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/conv2d_0"; +"159 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[0]/conv2d_0" -> "162 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[1]/batch_norm_0"; +"160 basenet.10.1.weight" -> "162 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[1]/batch_norm_0"; +"161 basenet.10.1.bias" -> "162 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[1]/batch_norm_0"; +"162 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[1]/batch_norm_0" -> "163 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/relu__0"; +"163 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/relu__0" -> "164 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"164 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "167 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/conv2d_0"; +"165 basenet.10.3.weight" -> "166 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"166 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "167 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/conv2d_0"; +"167 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/Conv2d[3]/conv2d_0" -> "170 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[4]/batch_norm_0"; +"168 basenet.10.4.weight" -> "170 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[4]/batch_norm_0"; +"169 basenet.10.4.bias" -> "170 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[4]/batch_norm_0"; +"170 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/BatchNorm2d[4]/batch_norm_0" -> "171 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/relu__0"; +"171 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/relu__0" -> "172 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"172 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[10]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "175 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/conv2d_0"; +"173 basenet.11.0.weight" -> "174 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"174 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "175 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/conv2d_0"; +"175 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[0]/conv2d_0" -> "178 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[1]/batch_norm_0"; +"176 basenet.11.1.weight" -> "178 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[1]/batch_norm_0"; +"177 basenet.11.1.bias" -> "178 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[1]/batch_norm_0"; +"178 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[1]/batch_norm_0" -> "179 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/relu__0"; +"179 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/relu__0" -> "180 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"180 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "183 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/conv2d_0"; +"181 basenet.11.3.weight" -> "182 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"182 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "183 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/conv2d_0"; +"183 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/Conv2d[3]/conv2d_0" -> "186 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[4]/batch_norm_0"; +"184 basenet.11.4.weight" -> "186 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[4]/batch_norm_0"; +"185 basenet.11.4.bias" -> "186 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[4]/batch_norm_0"; +"186 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/BatchNorm2d[4]/batch_norm_0" -> "187 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/relu__0"; +"187 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/relu__0" -> "188 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"188 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "191 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/conv2d_0"; +"188 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "288 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0"; +"188 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[11]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "292 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0"; +"189 basenet.12.0.weight" -> "190 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"190 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "191 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/conv2d_0"; +"191 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[0]/conv2d_0" -> "194 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[1]/batch_norm_0"; +"192 basenet.12.1.weight" -> "194 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[1]/batch_norm_0"; +"193 basenet.12.1.bias" -> "194 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[1]/batch_norm_0"; +"194 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[1]/batch_norm_0" -> "195 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/relu__0"; +"195 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/relu__0" -> "196 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"196 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "199 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/conv2d_0"; +"197 basenet.12.3.weight" -> "198 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"198 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "199 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/conv2d_0"; +"199 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/Conv2d[3]/conv2d_0" -> "202 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[4]/batch_norm_0"; +"200 basenet.12.4.weight" -> "202 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[4]/batch_norm_0"; +"201 basenet.12.4.bias" -> "202 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[4]/batch_norm_0"; +"202 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/BatchNorm2d[4]/batch_norm_0" -> "203 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/relu__0"; +"203 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/relu__0" -> "204 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"204 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[12]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "207 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/conv2d_0"; +"205 basenet.13.0.weight" -> "206 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"206 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "207 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/conv2d_0"; +"207 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[0]/conv2d_0" -> "210 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[1]/batch_norm_0"; +"208 basenet.13.1.weight" -> "210 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[1]/batch_norm_0"; +"209 basenet.13.1.bias" -> "210 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[1]/batch_norm_0"; +"210 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[1]/batch_norm_0" -> "211 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/relu__0"; +"211 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/relu__0" -> "212 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"212 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "215 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/conv2d_0"; +"213 basenet.13.3.weight" -> "214 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"214 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "215 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/conv2d_0"; +"215 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/Conv2d[3]/conv2d_0" -> "218 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[4]/batch_norm_0"; +"216 basenet.13.4.weight" -> "218 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[4]/batch_norm_0"; +"217 basenet.13.4.bias" -> "218 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[4]/batch_norm_0"; +"218 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/BatchNorm2d[4]/batch_norm_0" -> "219 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/relu__0"; +"219 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/relu__0" -> "220 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"220 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "223 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/conv2d_0"; +"220 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "300 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0"; +"220 MobileNetSSD/MultiOutputSequential[basenet]/Sequential[13]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "304 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0"; +"221 extras.0.0.weight" -> "222 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"222 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "223 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/conv2d_0"; +"223 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/Conv2d[0]/conv2d_0" -> "226 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/BatchNorm2d[1]/batch_norm_0"; +"224 extras.0.1.weight" -> "226 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/BatchNorm2d[1]/batch_norm_0"; +"225 extras.0.1.bias" -> "226 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/BatchNorm2d[1]/batch_norm_0"; +"226 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/BatchNorm2d[1]/batch_norm_0" -> "227 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/relu__0"; +"227 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/relu__0" -> "228 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"228 MobileNetSSD/MultiOutputSequential[extras]/Sequential[0]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "231 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/conv2d_0"; +"229 extras.1.0.weight" -> "230 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"230 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "231 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/conv2d_0"; +"231 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/Conv2d[0]/conv2d_0" -> "234 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/BatchNorm2d[1]/batch_norm_0"; +"232 extras.1.1.weight" -> "234 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/BatchNorm2d[1]/batch_norm_0"; +"233 extras.1.1.bias" -> "234 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/BatchNorm2d[1]/batch_norm_0"; +"234 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/BatchNorm2d[1]/batch_norm_0" -> "235 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/relu__0"; +"235 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/relu__0" -> "236 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"236 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "239 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/conv2d_0"; +"236 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "312 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0"; +"236 MobileNetSSD/MultiOutputSequential[extras]/Sequential[1]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "316 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0"; +"237 extras.2.0.weight" -> "238 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"238 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "239 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/conv2d_0"; +"239 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/Conv2d[0]/conv2d_0" -> "242 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/BatchNorm2d[1]/batch_norm_0"; +"240 extras.2.1.weight" -> "242 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/BatchNorm2d[1]/batch_norm_0"; +"241 extras.2.1.bias" -> "242 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/BatchNorm2d[1]/batch_norm_0"; +"242 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/BatchNorm2d[1]/batch_norm_0" -> "243 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/relu__0"; +"243 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/relu__0" -> "244 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"244 MobileNetSSD/MultiOutputSequential[extras]/Sequential[2]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "247 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/conv2d_0"; +"245 extras.3.0.weight" -> "246 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"246 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "247 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/conv2d_0"; +"247 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/Conv2d[0]/conv2d_0" -> "250 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/BatchNorm2d[1]/batch_norm_0"; +"248 extras.3.1.weight" -> "250 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/BatchNorm2d[1]/batch_norm_0"; +"249 extras.3.1.bias" -> "250 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/BatchNorm2d[1]/batch_norm_0"; +"250 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/BatchNorm2d[1]/batch_norm_0" -> "251 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/relu__0"; +"251 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/relu__0" -> "252 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"252 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "255 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/conv2d_0"; +"252 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "324 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0"; +"252 MobileNetSSD/MultiOutputSequential[extras]/Sequential[3]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "328 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0"; +"253 extras.4.0.weight" -> "254 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"254 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "255 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/conv2d_0"; +"255 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/Conv2d[0]/conv2d_0" -> "258 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/BatchNorm2d[1]/batch_norm_0"; +"256 extras.4.1.weight" -> "258 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/BatchNorm2d[1]/batch_norm_0"; +"257 extras.4.1.bias" -> "258 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/BatchNorm2d[1]/batch_norm_0"; +"258 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/BatchNorm2d[1]/batch_norm_0" -> "259 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/relu__0"; +"259 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/relu__0" -> "260 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"260 MobileNetSSD/MultiOutputSequential[extras]/Sequential[4]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "263 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/conv2d_0"; +"261 extras.5.0.weight" -> "262 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"262 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "263 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/conv2d_0"; +"263 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/Conv2d[0]/conv2d_0" -> "266 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/BatchNorm2d[1]/batch_norm_0"; +"264 extras.5.1.weight" -> "266 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/BatchNorm2d[1]/batch_norm_0"; +"265 extras.5.1.bias" -> "266 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/BatchNorm2d[1]/batch_norm_0"; +"266 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/BatchNorm2d[1]/batch_norm_0" -> "267 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/relu__0"; +"267 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/relu__0" -> "268 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"268 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "271 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/conv2d_0"; +"268 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0"; +"268 MobileNetSSD/MultiOutputSequential[extras]/Sequential[5]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "340 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0"; +"269 extras.6.0.weight" -> "270 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"270 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "271 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/conv2d_0"; +"271 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/Conv2d[0]/conv2d_0" -> "274 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/BatchNorm2d[1]/batch_norm_0"; +"272 extras.6.1.weight" -> "274 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/BatchNorm2d[1]/batch_norm_0"; +"273 extras.6.1.bias" -> "274 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/BatchNorm2d[1]/batch_norm_0"; +"274 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/BatchNorm2d[1]/batch_norm_0" -> "275 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/relu__0"; +"275 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/relu__0" -> "276 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"276 MobileNetSSD/MultiOutputSequential[extras]/Sequential[6]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "279 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/conv2d_0"; +"277 extras.7.0.weight" -> "278 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"278 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "279 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/conv2d_0"; +"279 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/Conv2d[0]/conv2d_0" -> "282 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/BatchNorm2d[1]/batch_norm_0"; +"280 extras.7.1.weight" -> "282 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/BatchNorm2d[1]/batch_norm_0"; +"281 extras.7.1.bias" -> "282 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/BatchNorm2d[1]/batch_norm_0"; +"282 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/BatchNorm2d[1]/batch_norm_0" -> "283 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/relu__0"; +"283 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/relu__0" -> "284 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"284 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "348 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0"; +"284 MobileNetSSD/MultiOutputSequential[extras]/Sequential[7]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "352 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0"; +"285 detection_head.heads.0.loc.weight" -> "287 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"286 detection_head.heads.0.loc.bias" -> "288 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0"; +"287 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "288 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0"; +"288 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0" -> "293 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0"; +"289 detection_head.heads.0.conf.weight" -> "291 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"290 detection_head.heads.0.conf.bias" -> "292 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0"; +"291 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "292 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0"; +"292 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0" -> "295 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1"; +"293 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" -> "294 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0"; +"294 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" -> "357 MobileNetSSD/SSDDetectionOutput[detection_head]/view_0"; +"295 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" -> "296 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1"; +"296 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" -> "364 MobileNetSSD/SSDDetectionOutput[detection_head]/view_6"; +"297 detection_head.heads.1.loc.weight" -> "299 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"298 detection_head.heads.1.loc.bias" -> "300 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0"; +"299 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "300 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0"; +"300 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0" -> "305 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0"; +"301 detection_head.heads.1.conf.weight" -> "303 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"302 detection_head.heads.1.conf.bias" -> "304 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0"; +"303 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "304 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0"; +"304 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0" -> "307 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1"; +"305 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" -> "306 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0"; +"306 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" -> "358 MobileNetSSD/SSDDetectionOutput[detection_head]/view_1"; +"307 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" -> "308 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1"; +"308 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" -> "365 MobileNetSSD/SSDDetectionOutput[detection_head]/view_7"; +"309 detection_head.heads.2.loc.weight" -> "311 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"310 detection_head.heads.2.loc.bias" -> "312 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0"; +"311 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "312 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0"; +"312 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0" -> "317 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0"; +"313 detection_head.heads.2.conf.weight" -> "315 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"314 detection_head.heads.2.conf.bias" -> "316 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0"; +"315 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "316 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0"; +"316 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0" -> "319 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1"; +"317 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" -> "318 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0"; +"318 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" -> "359 MobileNetSSD/SSDDetectionOutput[detection_head]/view_2"; +"319 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" -> "320 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1"; +"320 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" -> "366 MobileNetSSD/SSDDetectionOutput[detection_head]/view_8"; +"321 detection_head.heads.3.loc.weight" -> "323 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"322 detection_head.heads.3.loc.bias" -> "324 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0"; +"323 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "324 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0"; +"324 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0" -> "329 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0"; +"325 detection_head.heads.3.conf.weight" -> "327 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"326 detection_head.heads.3.conf.bias" -> "328 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0"; +"327 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "328 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0"; +"328 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0" -> "331 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1"; +"329 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" -> "330 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0"; +"330 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" -> "360 MobileNetSSD/SSDDetectionOutput[detection_head]/view_3"; +"331 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" -> "332 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1"; +"332 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" -> "367 MobileNetSSD/SSDDetectionOutput[detection_head]/view_9"; +"333 detection_head.heads.4.loc.weight" -> "335 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"334 detection_head.heads.4.loc.bias" -> "336 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0"; +"335 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0"; +"336 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0" -> "341 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0"; +"337 detection_head.heads.4.conf.weight" -> "339 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"338 detection_head.heads.4.conf.bias" -> "340 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0"; +"339 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "340 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0"; +"340 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0" -> "343 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1"; +"341 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" -> "342 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0"; +"342 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" -> "361 MobileNetSSD/SSDDetectionOutput[detection_head]/view_4"; +"343 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" -> "344 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1"; +"344 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" -> "368 MobileNetSSD/SSDDetectionOutput[detection_head]/view_10"; +"345 detection_head.heads.5.loc.weight" -> "347 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"346 detection_head.heads.5.loc.bias" -> "348 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0"; +"347 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "348 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0"; +"348 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0" -> "353 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0"; +"349 detection_head.heads.5.conf.weight" -> "351 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"350 detection_head.heads.5.conf.bias" -> "352 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0"; +"351 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "352 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0"; +"352 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0" -> "355 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1"; +"353 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" -> "354 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0"; +"354 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" -> "362 MobileNetSSD/SSDDetectionOutput[detection_head]/view_5"; +"355 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" -> "356 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1"; +"356 MobileNetSSD/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" -> "369 MobileNetSSD/SSDDetectionOutput[detection_head]/view_11"; +"357 MobileNetSSD/SSDDetectionOutput[detection_head]/view_0" -> "363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; +"358 MobileNetSSD/SSDDetectionOutput[detection_head]/view_1" -> "363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; +"359 MobileNetSSD/SSDDetectionOutput[detection_head]/view_2" -> "363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; +"360 MobileNetSSD/SSDDetectionOutput[detection_head]/view_3" -> "363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; +"361 MobileNetSSD/SSDDetectionOutput[detection_head]/view_4" -> "363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; +"362 MobileNetSSD/SSDDetectionOutput[detection_head]/view_5" -> "363 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_0"; +"364 MobileNetSSD/SSDDetectionOutput[detection_head]/view_6" -> "370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; +"365 MobileNetSSD/SSDDetectionOutput[detection_head]/view_7" -> "370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; +"366 MobileNetSSD/SSDDetectionOutput[detection_head]/view_8" -> "370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; +"367 MobileNetSSD/SSDDetectionOutput[detection_head]/view_9" -> "370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; +"368 MobileNetSSD/SSDDetectionOutput[detection_head]/view_10" -> "370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; +"369 MobileNetSSD/SSDDetectionOutput[detection_head]/view_11" -> "370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1"; +"370 MobileNetSSD/SSDDetectionOutput[detection_head]/cat_1" -> "371 MobileNetSSD/SSDDetectionOutput[detection_head]/view_12"; +"371 MobileNetSSD/SSDDetectionOutput[detection_head]/view_12" -> "372 MobileNetSSD/SSDDetectionOutput[detection_head]/softmax_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_vgg.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_vgg.dot index d4095a7d651..1ea8d4da1ad 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_vgg.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/ssd_vgg.dot @@ -4,401 +4,656 @@ strict digraph { "2 SSD_VGG/__getitem___0" [id=2, type=__getitem__]; "3 SSD_VGG/clone_0" [id=3, type=clone]; "4 SSD_VGG/unsqueeze_0" [id=4, type=unsqueeze]; -"5 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=5, type=symmetric_quantize]; -"6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d_0" [id=6, type=conv2d]; -"7 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[1]/batch_norm_0" [id=7, type=batch_norm]; -"8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/relu__0" [id=8, type=relu_]; -"9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=9, type=symmetric_quantize]; -"10 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=10, type=symmetric_quantize]; -"11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[3]/conv2d_0" [id=11, type=conv2d]; -"12 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[4]/batch_norm_0" [id=12, type=batch_norm]; -"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/relu__0" [id=13, type=relu_]; -"14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=14, type=symmetric_quantize]; -"15 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[6]/max_pool2d_0" [id=15, type=max_pool2d]; -"16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=16, type=symmetric_quantize]; -"17 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d_0" [id=17, type=conv2d]; -"18 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[8]/batch_norm_0" [id=18, type=batch_norm]; -"19 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/relu__0" [id=19, type=relu_]; -"20 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" [id=20, type=symmetric_quantize]; -"21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=21, type=symmetric_quantize]; -"22 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d_0" [id=22, type=conv2d]; -"23 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[11]/batch_norm_0" [id=23, type=batch_norm]; -"24 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/relu__0" [id=24, type=relu_]; -"25 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; -"26 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[13]/max_pool2d_0" [id=26, type=max_pool2d]; -"27 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=27, type=symmetric_quantize]; -"28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d_0" [id=28, type=conv2d]; -"29 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[15]/batch_norm_0" [id=29, type=batch_norm]; -"30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/relu__0" [id=30, type=relu_]; -"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" [id=31, type=symmetric_quantize]; -"32 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=32, type=symmetric_quantize]; -"33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d_0" [id=33, type=conv2d]; -"34 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[18]/batch_norm_0" [id=34, type=batch_norm]; -"35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/relu__0" [id=35, type=relu_]; -"36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" [id=36, type=symmetric_quantize]; -"37 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[20]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=37, type=symmetric_quantize]; -"38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[20]/conv2d_0" [id=38, type=conv2d]; -"39 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[21]/batch_norm_0" [id=39, type=batch_norm]; -"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/relu__0" [id=40, type=relu_]; -"41 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" [id=41, type=symmetric_quantize]; -"42 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d_0" [id=42, type=max_pool2d]; -"43 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=43, type=symmetric_quantize]; -"44 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d_0" [id=44, type=conv2d]; -"45 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[25]/batch_norm_0" [id=45, type=batch_norm]; -"46 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/relu__0" [id=46, type=relu_]; -"47 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" [id=47, type=symmetric_quantize]; -"48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[27]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=48, type=symmetric_quantize]; -"49 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[27]/conv2d_0" [id=49, type=conv2d]; -"50 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[28]/batch_norm_0" [id=50, type=batch_norm]; -"51 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/relu__0" [id=51, type=relu_]; -"52 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" [id=52, type=symmetric_quantize]; -"53 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[30]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=53, type=symmetric_quantize]; -"54 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[30]/conv2d_0" [id=54, type=conv2d]; -"55 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[31]/batch_norm_0" [id=55, type=batch_norm]; -"56 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/relu__0" [id=56, type=relu_]; -"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" [id=57, type=symmetric_quantize]; -"58 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[33]/max_pool2d_0" [id=58, type=max_pool2d]; -"59 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[34]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=59, type=symmetric_quantize]; -"60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[34]/conv2d_0" [id=60, type=conv2d]; -"61 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[35]/batch_norm_0" [id=61, type=batch_norm]; -"62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/relu__0" [id=62, type=relu_]; -"63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; -"64 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[37]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=64, type=symmetric_quantize]; -"65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[37]/conv2d_0" [id=65, type=conv2d]; -"66 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[38]/batch_norm_0" [id=66, type=batch_norm]; -"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/relu__0" [id=67, type=relu_]; -"68 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" [id=68, type=symmetric_quantize]; -"69 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[40]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=69, type=symmetric_quantize]; -"70 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[40]/conv2d_0" [id=70, type=conv2d]; -"71 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[41]/batch_norm_0" [id=71, type=batch_norm]; -"72 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/relu__0" [id=72, type=relu_]; -"73 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[43]/max_pool2d_0" [id=74, type=max_pool2d]; -"75 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[44]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[44]/conv2d_0" [id=76, type=conv2d]; -"77 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[45]/batch_norm_0" [id=77, type=batch_norm]; -"78 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/relu__0" [id=78, type=relu_]; -"79 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; -"80 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[47]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[47]/conv2d_0" [id=81, type=conv2d]; -"82 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[48]/batch_norm_0" [id=82, type=batch_norm]; -"83 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/relu__0" [id=83, type=relu_]; -"84 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" [id=84, type=symmetric_quantize]; -"85 SSD_VGG/NNCFUserL2Norm[L2Norm]/pow_0" [id=85, type=pow]; -"86 SSD_VGG/NNCFUserL2Norm[L2Norm]/sum_0" [id=86, type=sum]; -"87 SSD_VGG/NNCFUserL2Norm[L2Norm]/sqrt_0" [id=87, type=sqrt]; -"88 SSD_VGG/NNCFUserL2Norm[L2Norm]/__add___0" [id=88, type=__add__]; -"89 SSD_VGG/NNCFUserL2Norm[L2Norm]/div_0" [id=89, type=div]; -"90 SSD_VGG/NNCFUserL2Norm[L2Norm]/__rmul___0" [id=90, type=__rmul__]; -"91 SSD_VGG/NNCFUserL2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=92, type=symmetric_quantize]; -"93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d_0" [id=93, type=conv2d]; -"94 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[1]/batch_norm_0" [id=94, type=batch_norm]; -"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/relu__0" [id=95, type=relu_]; -"96 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=97, type=symmetric_quantize]; -"98 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[3]/conv2d_0" [id=98, type=conv2d]; -"99 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[4]/batch_norm_0" [id=99, type=batch_norm]; -"100 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/relu__0" [id=100, type=relu_]; -"101 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; -"102 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=102, type=symmetric_quantize]; -"103 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d_0" [id=103, type=conv2d]; -"104 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[7]/batch_norm_0" [id=104, type=batch_norm]; -"105 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/relu__0" [id=105, type=relu_]; -"106 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=106, type=symmetric_quantize]; -"107 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[9]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=107, type=symmetric_quantize]; -"108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[9]/conv2d_0" [id=108, type=conv2d]; -"109 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[10]/batch_norm_0" [id=109, type=batch_norm]; -"110 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/relu__0" [id=110, type=relu_]; -"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=112, type=symmetric_quantize]; -"113 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d_0" [id=113, type=conv2d]; -"114 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[13]/batch_norm_0" [id=114, type=batch_norm]; -"115 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/relu__0" [id=115, type=relu_]; -"116 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; -"117 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[15]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=117, type=symmetric_quantize]; -"118 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[15]/conv2d_0" [id=118, type=conv2d]; -"119 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[16]/batch_norm_0" [id=119, type=batch_norm]; -"120 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/relu__0" [id=120, type=relu_]; -"121 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" [id=121, type=symmetric_quantize]; -"122 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=122, type=symmetric_quantize]; -"123 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d_0" [id=123, type=conv2d]; -"124 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[19]/batch_norm_0" [id=124, type=batch_norm]; -"125 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/relu__0" [id=125, type=relu_]; -"126 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; -"127 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=127, type=symmetric_quantize]; -"128 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[21]/conv2d_0" [id=128, type=conv2d]; -"129 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[22]/batch_norm_0" [id=129, type=batch_norm]; -"130 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/relu__0" [id=130, type=relu_]; -"131 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; -"132 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=132, type=symmetric_quantize]; -"133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0" [id=133, type=conv2d]; -"134 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=134, type=symmetric_quantize]; -"135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0" [id=135, type=conv2d]; -"136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" [id=136, type=permute]; -"137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" [id=137, type=contiguous]; -"138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" [id=138, type=permute]; -"139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" [id=139, type=contiguous]; -"140 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=140, type=symmetric_quantize]; -"141 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0" [id=141, type=conv2d]; -"142 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=142, type=symmetric_quantize]; -"143 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0" [id=143, type=conv2d]; -"144 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" [id=144, type=permute]; -"145 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" [id=145, type=contiguous]; -"146 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" [id=146, type=permute]; -"147 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" [id=147, type=contiguous]; -"148 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=148, type=symmetric_quantize]; -"149 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0" [id=149, type=conv2d]; -"150 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=150, type=symmetric_quantize]; -"151 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0" [id=151, type=conv2d]; -"152 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" [id=152, type=permute]; -"153 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" [id=153, type=contiguous]; -"154 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" [id=154, type=permute]; -"155 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" [id=155, type=contiguous]; -"156 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=156, type=symmetric_quantize]; -"157 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0" [id=157, type=conv2d]; -"158 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=158, type=symmetric_quantize]; -"159 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0" [id=159, type=conv2d]; -"160 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" [id=160, type=permute]; -"161 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" [id=161, type=contiguous]; -"162 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" [id=162, type=permute]; -"163 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" [id=163, type=contiguous]; -"164 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=164, type=symmetric_quantize]; -"165 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0" [id=165, type=conv2d]; -"166 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=166, type=symmetric_quantize]; -"167 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0" [id=167, type=conv2d]; -"168 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" [id=168, type=permute]; -"169 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" [id=169, type=contiguous]; -"170 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" [id=170, type=permute]; -"171 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" [id=171, type=contiguous]; -"172 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=172, type=symmetric_quantize]; -"173 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0" [id=173, type=conv2d]; -"174 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=174, type=symmetric_quantize]; -"175 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0" [id=175, type=conv2d]; -"176 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" [id=176, type=permute]; -"177 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" [id=177, type=contiguous]; -"178 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" [id=178, type=permute]; -"179 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" [id=179, type=contiguous]; -"180 SSD_VGG/SSDDetectionOutput[detection_head]/view_0" [id=180, type=view]; -"181 SSD_VGG/SSDDetectionOutput[detection_head]/view_1" [id=181, type=view]; -"182 SSD_VGG/SSDDetectionOutput[detection_head]/view_2" [id=182, type=view]; -"183 SSD_VGG/SSDDetectionOutput[detection_head]/view_3" [id=183, type=view]; -"184 SSD_VGG/SSDDetectionOutput[detection_head]/view_4" [id=184, type=view]; -"185 SSD_VGG/SSDDetectionOutput[detection_head]/view_5" [id=185, type=view]; -"186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0" [id=186, type=cat]; -"187 SSD_VGG/SSDDetectionOutput[detection_head]/view_6" [id=187, type=view]; -"188 SSD_VGG/SSDDetectionOutput[detection_head]/view_7" [id=188, type=view]; -"189 SSD_VGG/SSDDetectionOutput[detection_head]/view_8" [id=189, type=view]; -"190 SSD_VGG/SSDDetectionOutput[detection_head]/view_9" [id=190, type=view]; -"191 SSD_VGG/SSDDetectionOutput[detection_head]/view_10" [id=191, type=view]; -"192 SSD_VGG/SSDDetectionOutput[detection_head]/view_11" [id=192, type=view]; -"193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1" [id=193, type=cat]; -"194 SSD_VGG/SSDDetectionOutput[detection_head]/view_12" [id=194, type=view]; -"195 SSD_VGG/SSDDetectionOutput[detection_head]/softmax_0" [id=195, type=softmax]; +"5 basenet.0.weight" [id=5, type=nncf_model_const]; +"6 basenet.0.bias" [id=6, type=nncf_model_const]; +"7 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/conv2d_0" [id=8, type=conv2d]; +"9 basenet.1.weight" [id=9, type=nncf_model_const]; +"10 basenet.1.bias" [id=10, type=nncf_model_const]; +"11 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[1]/batch_norm_0" [id=11, type=batch_norm]; +"12 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/relu__0" [id=12, type=relu_]; +"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 basenet.3.weight" [id=14, type=nncf_model_const]; +"15 basenet.3.bias" [id=15, type=nncf_model_const]; +"16 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=16, type=symmetric_quantize]; +"17 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/conv2d_0" [id=17, type=conv2d]; +"18 basenet.4.weight" [id=18, type=nncf_model_const]; +"19 basenet.4.bias" [id=19, type=nncf_model_const]; +"20 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[4]/batch_norm_0" [id=20, type=batch_norm]; +"21 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/relu__0" [id=21, type=relu_]; +"22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[6]/max_pool2d_0" [id=23, type=max_pool2d]; +"24 basenet.7.weight" [id=24, type=nncf_model_const]; +"25 basenet.7.bias" [id=25, type=nncf_model_const]; +"26 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/SymmetricQuantizer/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/conv2d_0" [id=27, type=conv2d]; +"28 basenet.8.weight" [id=28, type=nncf_model_const]; +"29 basenet.8.bias" [id=29, type=nncf_model_const]; +"30 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[8]/batch_norm_0" [id=30, type=batch_norm]; +"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/relu__0" [id=31, type=relu_]; +"32 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" [id=32, type=symmetric_quantize]; +"33 basenet.10.weight" [id=33, type=nncf_model_const]; +"34 basenet.10.bias" [id=34, type=nncf_model_const]; +"35 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0" [id=35, type=symmetric_quantize]; +"36 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/conv2d_0" [id=36, type=conv2d]; +"37 basenet.11.weight" [id=37, type=nncf_model_const]; +"38 basenet.11.bias" [id=38, type=nncf_model_const]; +"39 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[11]/batch_norm_0" [id=39, type=batch_norm]; +"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/relu__0" [id=40, type=relu_]; +"41 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" [id=41, type=symmetric_quantize]; +"42 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[13]/max_pool2d_0" [id=42, type=max_pool2d]; +"43 basenet.14.weight" [id=43, type=nncf_model_const]; +"44 basenet.14.bias" [id=44, type=nncf_model_const]; +"45 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/SymmetricQuantizer/symmetric_quantize_0" [id=45, type=symmetric_quantize]; +"46 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/conv2d_0" [id=46, type=conv2d]; +"47 basenet.15.weight" [id=47, type=nncf_model_const]; +"48 basenet.15.bias" [id=48, type=nncf_model_const]; +"49 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[15]/batch_norm_0" [id=49, type=batch_norm]; +"50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/relu__0" [id=50, type=relu_]; +"51 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 basenet.17.weight" [id=52, type=nncf_model_const]; +"53 basenet.17.bias" [id=53, type=nncf_model_const]; +"54 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; +"55 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/conv2d_0" [id=55, type=conv2d]; +"56 basenet.18.weight" [id=56, type=nncf_model_const]; +"57 basenet.18.bias" [id=57, type=nncf_model_const]; +"58 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[18]/batch_norm_0" [id=58, type=batch_norm]; +"59 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/relu__0" [id=59, type=relu_]; +"60 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 basenet.20.weight" [id=61, type=nncf_model_const]; +"62 basenet.20.bias" [id=62, type=nncf_model_const]; +"63 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/SymmetricQuantizer/symmetric_quantize_0" [id=63, type=symmetric_quantize]; +"64 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/conv2d_0" [id=64, type=conv2d]; +"65 basenet.21.weight" [id=65, type=nncf_model_const]; +"66 basenet.21.bias" [id=66, type=nncf_model_const]; +"67 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[21]/batch_norm_0" [id=67, type=batch_norm]; +"68 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/relu__0" [id=68, type=relu_]; +"69 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" [id=69, type=symmetric_quantize]; +"70 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d_0" [id=70, type=max_pool2d]; +"71 basenet.24.weight" [id=71, type=nncf_model_const]; +"72 basenet.24.bias" [id=72, type=nncf_model_const]; +"73 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; +"74 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/conv2d_0" [id=74, type=conv2d]; +"75 basenet.25.weight" [id=75, type=nncf_model_const]; +"76 basenet.25.bias" [id=76, type=nncf_model_const]; +"77 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[25]/batch_norm_0" [id=77, type=batch_norm]; +"78 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/relu__0" [id=78, type=relu_]; +"79 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; +"80 basenet.27.weight" [id=80, type=nncf_model_const]; +"81 basenet.27.bias" [id=81, type=nncf_model_const]; +"82 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/SymmetricQuantizer/symmetric_quantize_0" [id=82, type=symmetric_quantize]; +"83 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/conv2d_0" [id=83, type=conv2d]; +"84 basenet.28.weight" [id=84, type=nncf_model_const]; +"85 basenet.28.bias" [id=85, type=nncf_model_const]; +"86 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[28]/batch_norm_0" [id=86, type=batch_norm]; +"87 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/relu__0" [id=87, type=relu_]; +"88 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; +"89 basenet.30.weight" [id=89, type=nncf_model_const]; +"90 basenet.30.bias" [id=90, type=nncf_model_const]; +"91 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; +"92 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/conv2d_0" [id=92, type=conv2d]; +"93 basenet.31.weight" [id=93, type=nncf_model_const]; +"94 basenet.31.bias" [id=94, type=nncf_model_const]; +"95 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[31]/batch_norm_0" [id=95, type=batch_norm]; +"96 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/relu__0" [id=96, type=relu_]; +"97 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[33]/max_pool2d_0" [id=98, type=max_pool2d]; +"99 basenet.34.weight" [id=99, type=nncf_model_const]; +"100 basenet.34.bias" [id=100, type=nncf_model_const]; +"101 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/conv2d_0" [id=102, type=conv2d]; +"103 basenet.35.weight" [id=103, type=nncf_model_const]; +"104 basenet.35.bias" [id=104, type=nncf_model_const]; +"105 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[35]/batch_norm_0" [id=105, type=batch_norm]; +"106 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/relu__0" [id=106, type=relu_]; +"107 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" [id=107, type=symmetric_quantize]; +"108 basenet.37.weight" [id=108, type=nncf_model_const]; +"109 basenet.37.bias" [id=109, type=nncf_model_const]; +"110 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/conv2d_0" [id=111, type=conv2d]; +"112 basenet.38.weight" [id=112, type=nncf_model_const]; +"113 basenet.38.bias" [id=113, type=nncf_model_const]; +"114 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[38]/batch_norm_0" [id=114, type=batch_norm]; +"115 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/relu__0" [id=115, type=relu_]; +"116 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 basenet.40.weight" [id=117, type=nncf_model_const]; +"118 basenet.40.bias" [id=118, type=nncf_model_const]; +"119 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/SymmetricQuantizer/symmetric_quantize_0" [id=119, type=symmetric_quantize]; +"120 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/conv2d_0" [id=120, type=conv2d]; +"121 basenet.41.weight" [id=121, type=nncf_model_const]; +"122 basenet.41.bias" [id=122, type=nncf_model_const]; +"123 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[41]/batch_norm_0" [id=123, type=batch_norm]; +"124 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/relu__0" [id=124, type=relu_]; +"125 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" [id=125, type=symmetric_quantize]; +"126 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[43]/max_pool2d_0" [id=126, type=max_pool2d]; +"127 basenet.44.weight" [id=127, type=nncf_model_const]; +"128 basenet.44.bias" [id=128, type=nncf_model_const]; +"129 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/conv2d_0" [id=130, type=conv2d]; +"131 basenet.45.weight" [id=131, type=nncf_model_const]; +"132 basenet.45.bias" [id=132, type=nncf_model_const]; +"133 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[45]/batch_norm_0" [id=133, type=batch_norm]; +"134 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/relu__0" [id=134, type=relu_]; +"135 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/SymmetricQuantizer/symmetric_quantize_0" [id=135, type=symmetric_quantize]; +"136 basenet.47.weight" [id=136, type=nncf_model_const]; +"137 basenet.47.bias" [id=137, type=nncf_model_const]; +"138 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/SymmetricQuantizer/symmetric_quantize_0" [id=138, type=symmetric_quantize]; +"139 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/conv2d_0" [id=139, type=conv2d]; +"140 basenet.48.weight" [id=140, type=nncf_model_const]; +"141 basenet.48.bias" [id=141, type=nncf_model_const]; +"142 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[48]/batch_norm_0" [id=142, type=batch_norm]; +"143 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/relu__0" [id=143, type=relu_]; +"144 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" [id=144, type=symmetric_quantize]; +"145 SSD_VGG/L2Norm[L2Norm]/pow_0" [id=145, type=pow]; +"146 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0" [id=146, type=symmetric_quantize]; +"147 SSD_VGG/L2Norm[L2Norm]/sum_0" [id=147, type=sum]; +"148 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_1" [id=148, type=symmetric_quantize]; +"149 SSD_VGG/L2Norm[L2Norm]/sqrt_0" [id=149, type=sqrt]; +"150 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_2" [id=150, type=symmetric_quantize]; +"151 SSD_VGG/L2Norm[L2Norm]/__add___0" [id=151, type=__add__]; +"152 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_3" [id=152, type=symmetric_quantize]; +"153 SSD_VGG/L2Norm[L2Norm]/div_0" [id=153, type=div]; +"154 L2Norm.weight" [id=154, type=nncf_model_const]; +"155 SSD_VGG/L2Norm[L2Norm]/unsqueeze_0" [id=155, type=unsqueeze]; +"156 SSD_VGG/L2Norm[L2Norm]/unsqueeze_1" [id=156, type=unsqueeze]; +"157 SSD_VGG/L2Norm[L2Norm]/unsqueeze_2" [id=157, type=unsqueeze]; +"158 SSD_VGG/L2Norm[L2Norm]/expand_as_0" [id=158, type=expand_as]; +"159 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_4" [id=159, type=symmetric_quantize]; +"160 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_5" [id=160, type=symmetric_quantize]; +"161 SSD_VGG/L2Norm[L2Norm]/__mul___0" [id=161, type=__mul__]; +"162 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_6" [id=162, type=symmetric_quantize]; +"163 extras.0.weight" [id=163, type=nncf_model_const]; +"164 extras.0.bias" [id=164, type=nncf_model_const]; +"165 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=165, type=symmetric_quantize]; +"166 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/conv2d_0" [id=166, type=conv2d]; +"167 extras.1.weight" [id=167, type=nncf_model_const]; +"168 extras.1.bias" [id=168, type=nncf_model_const]; +"169 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[1]/batch_norm_0" [id=169, type=batch_norm]; +"170 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/relu__0" [id=170, type=relu_]; +"171 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=171, type=symmetric_quantize]; +"172 extras.3.weight" [id=172, type=nncf_model_const]; +"173 extras.3.bias" [id=173, type=nncf_model_const]; +"174 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=174, type=symmetric_quantize]; +"175 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/conv2d_0" [id=175, type=conv2d]; +"176 extras.4.weight" [id=176, type=nncf_model_const]; +"177 extras.4.bias" [id=177, type=nncf_model_const]; +"178 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[4]/batch_norm_0" [id=178, type=batch_norm]; +"179 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/relu__0" [id=179, type=relu_]; +"180 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=180, type=symmetric_quantize]; +"181 extras.6.weight" [id=181, type=nncf_model_const]; +"182 extras.6.bias" [id=182, type=nncf_model_const]; +"183 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/conv2d_0" [id=184, type=conv2d]; +"185 extras.7.weight" [id=185, type=nncf_model_const]; +"186 extras.7.bias" [id=186, type=nncf_model_const]; +"187 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[7]/batch_norm_0" [id=187, type=batch_norm]; +"188 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/relu__0" [id=188, type=relu_]; +"189 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" [id=189, type=symmetric_quantize]; +"190 extras.9.weight" [id=190, type=nncf_model_const]; +"191 extras.9.bias" [id=191, type=nncf_model_const]; +"192 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/SymmetricQuantizer/symmetric_quantize_0" [id=192, type=symmetric_quantize]; +"193 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/conv2d_0" [id=193, type=conv2d]; +"194 extras.10.weight" [id=194, type=nncf_model_const]; +"195 extras.10.bias" [id=195, type=nncf_model_const]; +"196 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[10]/batch_norm_0" [id=196, type=batch_norm]; +"197 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/relu__0" [id=197, type=relu_]; +"198 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; +"199 extras.12.weight" [id=199, type=nncf_model_const]; +"200 extras.12.bias" [id=200, type=nncf_model_const]; +"201 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/SymmetricQuantizer/symmetric_quantize_0" [id=201, type=symmetric_quantize]; +"202 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/conv2d_0" [id=202, type=conv2d]; +"203 extras.13.weight" [id=203, type=nncf_model_const]; +"204 extras.13.bias" [id=204, type=nncf_model_const]; +"205 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[13]/batch_norm_0" [id=205, type=batch_norm]; +"206 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/relu__0" [id=206, type=relu_]; +"207 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; +"208 extras.15.weight" [id=208, type=nncf_model_const]; +"209 extras.15.bias" [id=209, type=nncf_model_const]; +"210 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/SymmetricQuantizer/symmetric_quantize_0" [id=210, type=symmetric_quantize]; +"211 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/conv2d_0" [id=211, type=conv2d]; +"212 extras.16.weight" [id=212, type=nncf_model_const]; +"213 extras.16.bias" [id=213, type=nncf_model_const]; +"214 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[16]/batch_norm_0" [id=214, type=batch_norm]; +"215 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/relu__0" [id=215, type=relu_]; +"216 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" [id=216, type=symmetric_quantize]; +"217 extras.18.weight" [id=217, type=nncf_model_const]; +"218 extras.18.bias" [id=218, type=nncf_model_const]; +"219 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/SymmetricQuantizer/symmetric_quantize_0" [id=219, type=symmetric_quantize]; +"220 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/conv2d_0" [id=220, type=conv2d]; +"221 extras.19.weight" [id=221, type=nncf_model_const]; +"222 extras.19.bias" [id=222, type=nncf_model_const]; +"223 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[19]/batch_norm_0" [id=223, type=batch_norm]; +"224 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/relu__0" [id=224, type=relu_]; +"225 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/SymmetricQuantizer/symmetric_quantize_0" [id=225, type=symmetric_quantize]; +"226 extras.21.weight" [id=226, type=nncf_model_const]; +"227 extras.21.bias" [id=227, type=nncf_model_const]; +"228 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/conv2d_0" [id=229, type=conv2d]; +"230 extras.22.weight" [id=230, type=nncf_model_const]; +"231 extras.22.bias" [id=231, type=nncf_model_const]; +"232 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[22]/batch_norm_0" [id=232, type=batch_norm]; +"233 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/relu__0" [id=233, type=relu_]; +"234 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 detection_head.heads.0.loc.weight" [id=235, type=nncf_model_const]; +"236 detection_head.heads.0.loc.bias" [id=236, type=nncf_model_const]; +"237 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=237, type=symmetric_quantize]; +"238 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0" [id=238, type=conv2d]; +"239 detection_head.heads.0.conf.weight" [id=239, type=nncf_model_const]; +"240 detection_head.heads.0.conf.bias" [id=240, type=nncf_model_const]; +"241 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0" [id=242, type=conv2d]; +"243 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" [id=243, type=permute]; +"244 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" [id=244, type=contiguous]; +"245 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" [id=245, type=permute]; +"246 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" [id=246, type=contiguous]; +"247 detection_head.heads.1.loc.weight" [id=247, type=nncf_model_const]; +"248 detection_head.heads.1.loc.bias" [id=248, type=nncf_model_const]; +"249 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=249, type=symmetric_quantize]; +"250 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0" [id=250, type=conv2d]; +"251 detection_head.heads.1.conf.weight" [id=251, type=nncf_model_const]; +"252 detection_head.heads.1.conf.bias" [id=252, type=nncf_model_const]; +"253 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=253, type=symmetric_quantize]; +"254 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0" [id=254, type=conv2d]; +"255 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" [id=255, type=permute]; +"256 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" [id=256, type=contiguous]; +"257 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" [id=257, type=permute]; +"258 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" [id=258, type=contiguous]; +"259 detection_head.heads.2.loc.weight" [id=259, type=nncf_model_const]; +"260 detection_head.heads.2.loc.bias" [id=260, type=nncf_model_const]; +"261 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=261, type=symmetric_quantize]; +"262 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0" [id=262, type=conv2d]; +"263 detection_head.heads.2.conf.weight" [id=263, type=nncf_model_const]; +"264 detection_head.heads.2.conf.bias" [id=264, type=nncf_model_const]; +"265 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=265, type=symmetric_quantize]; +"266 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0" [id=266, type=conv2d]; +"267 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" [id=267, type=permute]; +"268 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" [id=268, type=contiguous]; +"269 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" [id=269, type=permute]; +"270 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" [id=270, type=contiguous]; +"271 detection_head.heads.3.loc.weight" [id=271, type=nncf_model_const]; +"272 detection_head.heads.3.loc.bias" [id=272, type=nncf_model_const]; +"273 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=273, type=symmetric_quantize]; +"274 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0" [id=274, type=conv2d]; +"275 detection_head.heads.3.conf.weight" [id=275, type=nncf_model_const]; +"276 detection_head.heads.3.conf.bias" [id=276, type=nncf_model_const]; +"277 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=277, type=symmetric_quantize]; +"278 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0" [id=278, type=conv2d]; +"279 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" [id=279, type=permute]; +"280 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" [id=280, type=contiguous]; +"281 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" [id=281, type=permute]; +"282 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" [id=282, type=contiguous]; +"283 detection_head.heads.4.loc.weight" [id=283, type=nncf_model_const]; +"284 detection_head.heads.4.loc.bias" [id=284, type=nncf_model_const]; +"285 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=285, type=symmetric_quantize]; +"286 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0" [id=286, type=conv2d]; +"287 detection_head.heads.4.conf.weight" [id=287, type=nncf_model_const]; +"288 detection_head.heads.4.conf.bias" [id=288, type=nncf_model_const]; +"289 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0" [id=290, type=conv2d]; +"291 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" [id=291, type=permute]; +"292 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" [id=292, type=contiguous]; +"293 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" [id=293, type=permute]; +"294 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" [id=294, type=contiguous]; +"295 detection_head.heads.5.loc.weight" [id=295, type=nncf_model_const]; +"296 detection_head.heads.5.loc.bias" [id=296, type=nncf_model_const]; +"297 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" [id=297, type=symmetric_quantize]; +"298 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0" [id=298, type=conv2d]; +"299 detection_head.heads.5.conf.weight" [id=299, type=nncf_model_const]; +"300 detection_head.heads.5.conf.bias" [id=300, type=nncf_model_const]; +"301 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" [id=301, type=symmetric_quantize]; +"302 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0" [id=302, type=conv2d]; +"303 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" [id=303, type=permute]; +"304 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" [id=304, type=contiguous]; +"305 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" [id=305, type=permute]; +"306 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" [id=306, type=contiguous]; +"307 SSD_VGG/SSDDetectionOutput[detection_head]/view_0" [id=307, type=view]; +"308 SSD_VGG/SSDDetectionOutput[detection_head]/view_1" [id=308, type=view]; +"309 SSD_VGG/SSDDetectionOutput[detection_head]/view_2" [id=309, type=view]; +"310 SSD_VGG/SSDDetectionOutput[detection_head]/view_3" [id=310, type=view]; +"311 SSD_VGG/SSDDetectionOutput[detection_head]/view_4" [id=311, type=view]; +"312 SSD_VGG/SSDDetectionOutput[detection_head]/view_5" [id=312, type=view]; +"313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0" [id=313, type=cat]; +"314 SSD_VGG/SSDDetectionOutput[detection_head]/view_6" [id=314, type=view]; +"315 SSD_VGG/SSDDetectionOutput[detection_head]/view_7" [id=315, type=view]; +"316 SSD_VGG/SSDDetectionOutput[detection_head]/view_8" [id=316, type=view]; +"317 SSD_VGG/SSDDetectionOutput[detection_head]/view_9" [id=317, type=view]; +"318 SSD_VGG/SSDDetectionOutput[detection_head]/view_10" [id=318, type=view]; +"319 SSD_VGG/SSDDetectionOutput[detection_head]/view_11" [id=319, type=view]; +"320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1" [id=320, type=cat]; +"321 SSD_VGG/SSDDetectionOutput[detection_head]/view_12" [id=321, type=view]; +"322 SSD_VGG/SSDDetectionOutput[detection_head]/softmax_0" [id=322, type=softmax]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; "1 SymmetricQuantizer/symmetric_quantize_0" -> "2 SSD_VGG/__getitem___0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "8 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/conv2d_0"; "2 SSD_VGG/__getitem___0" -> "3 SSD_VGG/clone_0"; "3 SSD_VGG/clone_0" -> "4 SSD_VGG/unsqueeze_0"; -"5 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d_0"; -"6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d_0" -> "7 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[1]/batch_norm_0"; -"7 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[1]/batch_norm_0" -> "8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/relu__0"; -"8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/relu__0" -> "9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[3]/conv2d_0"; -"10 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[3]/conv2d_0"; -"11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[3]/conv2d_0" -> "12 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[4]/batch_norm_0"; -"12 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[4]/batch_norm_0" -> "13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/relu__0"; -"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/relu__0" -> "14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "15 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[6]/max_pool2d_0"; -"15 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[6]/max_pool2d_0" -> "17 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d_0"; -"16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "17 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d_0"; -"17 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d_0" -> "18 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[8]/batch_norm_0"; -"18 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[8]/batch_norm_0" -> "19 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/relu__0"; -"19 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/relu__0" -> "20 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0"; -"20 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" -> "22 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d_0"; -"21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "22 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d_0"; -"22 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d_0" -> "23 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[11]/batch_norm_0"; -"23 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[11]/batch_norm_0" -> "24 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/relu__0"; -"24 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/relu__0" -> "25 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0"; -"25 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" -> "26 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[13]/max_pool2d_0"; -"26 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[13]/max_pool2d_0" -> "28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d_0"; -"27 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d_0"; -"28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d_0" -> "29 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[15]/batch_norm_0"; -"29 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[15]/batch_norm_0" -> "30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/relu__0"; -"30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/relu__0" -> "31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0"; -"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" -> "33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d_0"; -"32 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d_0"; -"33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d_0" -> "34 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[18]/batch_norm_0"; -"34 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[18]/batch_norm_0" -> "35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/relu__0"; -"35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/relu__0" -> "36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0"; -"36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" -> "38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[20]/conv2d_0"; -"37 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[20]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[20]/conv2d_0"; -"38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[20]/conv2d_0" -> "39 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[21]/batch_norm_0"; -"39 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[21]/batch_norm_0" -> "40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/relu__0"; -"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/relu__0" -> "41 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0"; -"41 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" -> "42 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d_0"; -"42 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d_0" -> "44 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d_0"; -"43 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "44 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d_0"; -"44 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d_0" -> "45 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[25]/batch_norm_0"; -"45 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[25]/batch_norm_0" -> "46 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/relu__0"; -"46 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/relu__0" -> "47 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0"; -"47 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" -> "49 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[27]/conv2d_0"; -"48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[27]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "49 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[27]/conv2d_0"; -"49 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[27]/conv2d_0" -> "50 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[28]/batch_norm_0"; -"50 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[28]/batch_norm_0" -> "51 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/relu__0"; -"51 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/relu__0" -> "52 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0"; -"52 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" -> "54 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[30]/conv2d_0"; -"53 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[30]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "54 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[30]/conv2d_0"; -"54 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[30]/conv2d_0" -> "55 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[31]/batch_norm_0"; -"55 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[31]/batch_norm_0" -> "56 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/relu__0"; -"56 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/relu__0" -> "57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0"; -"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "58 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[33]/max_pool2d_0"; -"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "85 SSD_VGG/NNCFUserL2Norm[L2Norm]/pow_0"; -"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "89 SSD_VGG/NNCFUserL2Norm[L2Norm]/div_0"; -"58 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[33]/max_pool2d_0" -> "60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[34]/conv2d_0"; -"59 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[34]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[34]/conv2d_0"; -"60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[34]/conv2d_0" -> "61 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[35]/batch_norm_0"; -"61 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[35]/batch_norm_0" -> "62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/relu__0"; -"62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/relu__0" -> "63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0"; -"63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" -> "65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[37]/conv2d_0"; -"64 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[37]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[37]/conv2d_0"; -"65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[37]/conv2d_0" -> "66 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[38]/batch_norm_0"; -"66 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[38]/batch_norm_0" -> "67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/relu__0"; -"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/relu__0" -> "68 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0"; -"68 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" -> "70 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[40]/conv2d_0"; -"69 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[40]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "70 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[40]/conv2d_0"; -"70 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[40]/conv2d_0" -> "71 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[41]/batch_norm_0"; -"71 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[41]/batch_norm_0" -> "72 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/relu__0"; -"72 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/relu__0" -> "73 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0"; -"73 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" -> "74 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[43]/max_pool2d_0"; -"74 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[43]/max_pool2d_0" -> "76 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[44]/conv2d_0"; -"75 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[44]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "76 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[44]/conv2d_0"; -"76 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[44]/conv2d_0" -> "77 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[45]/batch_norm_0"; -"77 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[45]/batch_norm_0" -> "78 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/relu__0"; -"78 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/relu__0" -> "79 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/SymmetricQuantizer/symmetric_quantize_0"; -"79 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/SymmetricQuantizer/symmetric_quantize_0" -> "81 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[47]/conv2d_0"; -"80 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[47]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "81 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[47]/conv2d_0"; -"81 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[47]/conv2d_0" -> "82 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[48]/batch_norm_0"; -"82 SSD_VGG/MultiOutputSequential[basenet]/NNCFBatchNorm2d[48]/batch_norm_0" -> "83 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/relu__0"; -"83 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/relu__0" -> "84 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0"; -"84 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" -> "93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d_0"; -"84 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0"; -"84 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" -> "143 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0"; -"85 SSD_VGG/NNCFUserL2Norm[L2Norm]/pow_0" -> "86 SSD_VGG/NNCFUserL2Norm[L2Norm]/sum_0"; -"86 SSD_VGG/NNCFUserL2Norm[L2Norm]/sum_0" -> "87 SSD_VGG/NNCFUserL2Norm[L2Norm]/sqrt_0"; -"87 SSD_VGG/NNCFUserL2Norm[L2Norm]/sqrt_0" -> "88 SSD_VGG/NNCFUserL2Norm[L2Norm]/__add___0"; -"88 SSD_VGG/NNCFUserL2Norm[L2Norm]/__add___0" -> "89 SSD_VGG/NNCFUserL2Norm[L2Norm]/div_0"; -"89 SSD_VGG/NNCFUserL2Norm[L2Norm]/div_0" -> "90 SSD_VGG/NNCFUserL2Norm[L2Norm]/__rmul___0"; -"90 SSD_VGG/NNCFUserL2Norm[L2Norm]/__rmul___0" -> "91 SSD_VGG/NNCFUserL2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0"; -"91 SSD_VGG/NNCFUserL2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0" -> "133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0"; -"91 SSD_VGG/NNCFUserL2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0" -> "135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0"; -"92 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d_0"; -"93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d_0" -> "94 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[1]/batch_norm_0"; -"94 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[1]/batch_norm_0" -> "95 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/relu__0"; -"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/relu__0" -> "96 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"96 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "98 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[3]/conv2d_0"; -"97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "98 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[3]/conv2d_0"; -"98 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[3]/conv2d_0" -> "99 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[4]/batch_norm_0"; -"99 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[4]/batch_norm_0" -> "100 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/relu__0"; -"100 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/relu__0" -> "101 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"101 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "103 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d_0"; -"101 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "149 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0"; -"101 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "151 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0"; -"102 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "103 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d_0"; -"103 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d_0" -> "104 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[7]/batch_norm_0"; -"104 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[7]/batch_norm_0" -> "105 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/relu__0"; -"105 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/relu__0" -> "106 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; -"106 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[9]/conv2d_0"; -"107 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[9]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[9]/conv2d_0"; -"108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[9]/conv2d_0" -> "109 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[10]/batch_norm_0"; -"109 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[10]/batch_norm_0" -> "110 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/relu__0"; -"110 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/relu__0" -> "111 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0"; -"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "113 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d_0"; -"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "157 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0"; -"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "159 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0"; -"112 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "113 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d_0"; -"113 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d_0" -> "114 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[13]/batch_norm_0"; -"114 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[13]/batch_norm_0" -> "115 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/relu__0"; -"115 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/relu__0" -> "116 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/SymmetricQuantizer/symmetric_quantize_0"; -"116 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/SymmetricQuantizer/symmetric_quantize_0" -> "118 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[15]/conv2d_0"; -"117 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[15]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "118 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[15]/conv2d_0"; -"118 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[15]/conv2d_0" -> "119 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[16]/batch_norm_0"; -"119 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[16]/batch_norm_0" -> "120 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/relu__0"; -"120 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/relu__0" -> "121 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0"; -"121 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" -> "123 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d_0"; -"121 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" -> "165 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0"; -"121 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" -> "167 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0"; -"122 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "123 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d_0"; -"123 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d_0" -> "124 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[19]/batch_norm_0"; -"124 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[19]/batch_norm_0" -> "125 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/relu__0"; -"125 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/relu__0" -> "126 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/SymmetricQuantizer/symmetric_quantize_0"; -"126 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/SymmetricQuantizer/symmetric_quantize_0" -> "128 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[21]/conv2d_0"; -"127 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "128 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[21]/conv2d_0"; -"128 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[21]/conv2d_0" -> "129 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[22]/batch_norm_0"; -"129 SSD_VGG/MultiOutputSequential[extras]/NNCFBatchNorm2d[22]/batch_norm_0" -> "130 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/relu__0"; -"130 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/relu__0" -> "131 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0"; -"131 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0" -> "173 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0"; -"131 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0" -> "175 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0"; -"132 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0"; -"133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d_0" -> "136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0"; -"134 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0"; -"135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d_0" -> "138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1"; -"136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" -> "137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0"; -"137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" -> "180 SSD_VGG/SSDDetectionOutput[detection_head]/view_0"; -"138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" -> "139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1"; -"139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" -> "187 SSD_VGG/SSDDetectionOutput[detection_head]/view_6"; -"140 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0"; -"141 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d_0" -> "144 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0"; -"142 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "143 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0"; -"143 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d_0" -> "146 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1"; -"144 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" -> "145 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0"; -"145 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" -> "181 SSD_VGG/SSDDetectionOutput[detection_head]/view_1"; -"146 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" -> "147 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1"; -"147 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" -> "188 SSD_VGG/SSDDetectionOutput[detection_head]/view_7"; -"148 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "149 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0"; -"149 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d_0" -> "152 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0"; -"150 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "151 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0"; -"151 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d_0" -> "154 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1"; -"152 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" -> "153 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0"; -"153 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" -> "182 SSD_VGG/SSDDetectionOutput[detection_head]/view_2"; -"154 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" -> "155 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1"; -"155 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" -> "189 SSD_VGG/SSDDetectionOutput[detection_head]/view_8"; -"156 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "157 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0"; -"157 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d_0" -> "160 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0"; -"158 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "159 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0"; -"159 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d_0" -> "162 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1"; -"160 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" -> "161 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0"; -"161 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" -> "183 SSD_VGG/SSDDetectionOutput[detection_head]/view_3"; -"162 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" -> "163 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1"; -"163 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" -> "190 SSD_VGG/SSDDetectionOutput[detection_head]/view_9"; -"164 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "165 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0"; -"165 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d_0" -> "168 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0"; -"166 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "167 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0"; -"167 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d_0" -> "170 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1"; -"168 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" -> "169 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0"; -"169 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" -> "184 SSD_VGG/SSDDetectionOutput[detection_head]/view_4"; -"170 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" -> "171 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1"; -"171 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" -> "191 SSD_VGG/SSDDetectionOutput[detection_head]/view_10"; -"172 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "173 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0"; -"173 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d_0" -> "176 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0"; -"174 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "175 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0"; -"175 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d_0" -> "178 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1"; -"176 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" -> "177 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0"; -"177 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" -> "185 SSD_VGG/SSDDetectionOutput[detection_head]/view_5"; -"178 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" -> "179 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1"; -"179 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" -> "192 SSD_VGG/SSDDetectionOutput[detection_head]/view_11"; -"180 SSD_VGG/SSDDetectionOutput[detection_head]/view_0" -> "186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; -"181 SSD_VGG/SSDDetectionOutput[detection_head]/view_1" -> "186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; -"182 SSD_VGG/SSDDetectionOutput[detection_head]/view_2" -> "186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; -"183 SSD_VGG/SSDDetectionOutput[detection_head]/view_3" -> "186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; -"184 SSD_VGG/SSDDetectionOutput[detection_head]/view_4" -> "186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; -"185 SSD_VGG/SSDDetectionOutput[detection_head]/view_5" -> "186 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; -"187 SSD_VGG/SSDDetectionOutput[detection_head]/view_6" -> "193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; -"188 SSD_VGG/SSDDetectionOutput[detection_head]/view_7" -> "193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; -"189 SSD_VGG/SSDDetectionOutput[detection_head]/view_8" -> "193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; -"190 SSD_VGG/SSDDetectionOutput[detection_head]/view_9" -> "193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; -"191 SSD_VGG/SSDDetectionOutput[detection_head]/view_10" -> "193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; -"192 SSD_VGG/SSDDetectionOutput[detection_head]/view_11" -> "193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; -"193 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1" -> "194 SSD_VGG/SSDDetectionOutput[detection_head]/view_12"; -"194 SSD_VGG/SSDDetectionOutput[detection_head]/view_12" -> "195 SSD_VGG/SSDDetectionOutput[detection_head]/softmax_0"; +"5 basenet.0.weight" -> "7 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"6 basenet.0.bias" -> "8 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/conv2d_0"; +"7 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "8 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/conv2d_0"; +"8 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[0]/conv2d_0" -> "11 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[1]/batch_norm_0"; +"9 basenet.1.weight" -> "11 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[1]/batch_norm_0"; +"10 basenet.1.bias" -> "11 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[1]/batch_norm_0"; +"11 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[1]/batch_norm_0" -> "12 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/relu__0"; +"12 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/relu__0" -> "13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "17 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/conv2d_0"; +"14 basenet.3.weight" -> "16 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"15 basenet.3.bias" -> "17 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/conv2d_0"; +"16 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "17 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/conv2d_0"; +"17 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[3]/conv2d_0" -> "20 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[4]/batch_norm_0"; +"18 basenet.4.weight" -> "20 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[4]/batch_norm_0"; +"19 basenet.4.bias" -> "20 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[4]/batch_norm_0"; +"20 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[4]/batch_norm_0" -> "21 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/relu__0"; +"21 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/relu__0" -> "22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "23 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[6]/max_pool2d_0"; +"23 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[6]/max_pool2d_0" -> "27 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/conv2d_0"; +"24 basenet.7.weight" -> "26 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/SymmetricQuantizer/symmetric_quantize_0"; +"25 basenet.7.bias" -> "27 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/conv2d_0"; +"26 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/SymmetricQuantizer/symmetric_quantize_0" -> "27 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/conv2d_0"; +"27 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[7]/conv2d_0" -> "30 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[8]/batch_norm_0"; +"28 basenet.8.weight" -> "30 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[8]/batch_norm_0"; +"29 basenet.8.bias" -> "30 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[8]/batch_norm_0"; +"30 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[8]/batch_norm_0" -> "31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/relu__0"; +"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/relu__0" -> "32 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0"; +"32 SSD_VGG/MultiOutputSequential[basenet]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" -> "36 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/conv2d_0"; +"33 basenet.10.weight" -> "35 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0"; +"34 basenet.10.bias" -> "36 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/conv2d_0"; +"35 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0" -> "36 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/conv2d_0"; +"36 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[10]/conv2d_0" -> "39 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[11]/batch_norm_0"; +"37 basenet.11.weight" -> "39 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[11]/batch_norm_0"; +"38 basenet.11.bias" -> "39 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[11]/batch_norm_0"; +"39 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[11]/batch_norm_0" -> "40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/relu__0"; +"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/relu__0" -> "41 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0"; +"41 SSD_VGG/MultiOutputSequential[basenet]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" -> "42 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[13]/max_pool2d_0"; +"42 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[13]/max_pool2d_0" -> "46 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/conv2d_0"; +"43 basenet.14.weight" -> "45 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/SymmetricQuantizer/symmetric_quantize_0"; +"44 basenet.14.bias" -> "46 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/conv2d_0"; +"45 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/SymmetricQuantizer/symmetric_quantize_0" -> "46 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/conv2d_0"; +"46 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[14]/conv2d_0" -> "49 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[15]/batch_norm_0"; +"47 basenet.15.weight" -> "49 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[15]/batch_norm_0"; +"48 basenet.15.bias" -> "49 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[15]/batch_norm_0"; +"49 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[15]/batch_norm_0" -> "50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/relu__0"; +"50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/relu__0" -> "51 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0"; +"51 SSD_VGG/MultiOutputSequential[basenet]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" -> "55 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/conv2d_0"; +"52 basenet.17.weight" -> "54 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/SymmetricQuantizer/symmetric_quantize_0"; +"53 basenet.17.bias" -> "55 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/conv2d_0"; +"54 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/SymmetricQuantizer/symmetric_quantize_0" -> "55 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/conv2d_0"; +"55 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[17]/conv2d_0" -> "58 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[18]/batch_norm_0"; +"56 basenet.18.weight" -> "58 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[18]/batch_norm_0"; +"57 basenet.18.bias" -> "58 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[18]/batch_norm_0"; +"58 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[18]/batch_norm_0" -> "59 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/relu__0"; +"59 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/relu__0" -> "60 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0"; +"60 SSD_VGG/MultiOutputSequential[basenet]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" -> "64 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/conv2d_0"; +"61 basenet.20.weight" -> "63 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/SymmetricQuantizer/symmetric_quantize_0"; +"62 basenet.20.bias" -> "64 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/conv2d_0"; +"63 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/SymmetricQuantizer/symmetric_quantize_0" -> "64 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/conv2d_0"; +"64 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[20]/conv2d_0" -> "67 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[21]/batch_norm_0"; +"65 basenet.21.weight" -> "67 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[21]/batch_norm_0"; +"66 basenet.21.bias" -> "67 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[21]/batch_norm_0"; +"67 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[21]/batch_norm_0" -> "68 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/relu__0"; +"68 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/relu__0" -> "69 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0"; +"69 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" -> "70 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d_0"; +"70 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d_0" -> "74 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/conv2d_0"; +"71 basenet.24.weight" -> "73 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/SymmetricQuantizer/symmetric_quantize_0"; +"72 basenet.24.bias" -> "74 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/conv2d_0"; +"73 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/SymmetricQuantizer/symmetric_quantize_0" -> "74 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/conv2d_0"; +"74 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[24]/conv2d_0" -> "77 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[25]/batch_norm_0"; +"75 basenet.25.weight" -> "77 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[25]/batch_norm_0"; +"76 basenet.25.bias" -> "77 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[25]/batch_norm_0"; +"77 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[25]/batch_norm_0" -> "78 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/relu__0"; +"78 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/relu__0" -> "79 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0"; +"79 SSD_VGG/MultiOutputSequential[basenet]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" -> "83 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/conv2d_0"; +"80 basenet.27.weight" -> "82 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/SymmetricQuantizer/symmetric_quantize_0"; +"81 basenet.27.bias" -> "83 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/conv2d_0"; +"82 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/SymmetricQuantizer/symmetric_quantize_0" -> "83 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/conv2d_0"; +"83 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[27]/conv2d_0" -> "86 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[28]/batch_norm_0"; +"84 basenet.28.weight" -> "86 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[28]/batch_norm_0"; +"85 basenet.28.bias" -> "86 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[28]/batch_norm_0"; +"86 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[28]/batch_norm_0" -> "87 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/relu__0"; +"87 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/relu__0" -> "88 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0"; +"88 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" -> "92 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/conv2d_0"; +"89 basenet.30.weight" -> "91 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/SymmetricQuantizer/symmetric_quantize_0"; +"90 basenet.30.bias" -> "92 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/conv2d_0"; +"91 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/SymmetricQuantizer/symmetric_quantize_0" -> "92 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/conv2d_0"; +"92 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[30]/conv2d_0" -> "95 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[31]/batch_norm_0"; +"93 basenet.31.weight" -> "95 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[31]/batch_norm_0"; +"94 basenet.31.bias" -> "95 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[31]/batch_norm_0"; +"95 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[31]/batch_norm_0" -> "96 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/relu__0"; +"96 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/relu__0" -> "97 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0"; +"97 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "98 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[33]/max_pool2d_0"; +"97 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "145 SSD_VGG/L2Norm[L2Norm]/pow_0"; +"97 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "153 SSD_VGG/L2Norm[L2Norm]/div_0"; +"98 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[33]/max_pool2d_0" -> "102 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/conv2d_0"; +"99 basenet.34.weight" -> "101 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/SymmetricQuantizer/symmetric_quantize_0"; +"100 basenet.34.bias" -> "102 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/conv2d_0"; +"101 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/SymmetricQuantizer/symmetric_quantize_0" -> "102 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/conv2d_0"; +"102 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[34]/conv2d_0" -> "105 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[35]/batch_norm_0"; +"103 basenet.35.weight" -> "105 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[35]/batch_norm_0"; +"104 basenet.35.bias" -> "105 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[35]/batch_norm_0"; +"105 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[35]/batch_norm_0" -> "106 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/relu__0"; +"106 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/relu__0" -> "107 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0"; +"107 SSD_VGG/MultiOutputSequential[basenet]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" -> "111 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/conv2d_0"; +"108 basenet.37.weight" -> "110 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/SymmetricQuantizer/symmetric_quantize_0"; +"109 basenet.37.bias" -> "111 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/conv2d_0"; +"110 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/SymmetricQuantizer/symmetric_quantize_0" -> "111 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/conv2d_0"; +"111 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[37]/conv2d_0" -> "114 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[38]/batch_norm_0"; +"112 basenet.38.weight" -> "114 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[38]/batch_norm_0"; +"113 basenet.38.bias" -> "114 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[38]/batch_norm_0"; +"114 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[38]/batch_norm_0" -> "115 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/relu__0"; +"115 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/relu__0" -> "116 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0"; +"116 SSD_VGG/MultiOutputSequential[basenet]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" -> "120 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/conv2d_0"; +"117 basenet.40.weight" -> "119 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/SymmetricQuantizer/symmetric_quantize_0"; +"118 basenet.40.bias" -> "120 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/conv2d_0"; +"119 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/SymmetricQuantizer/symmetric_quantize_0" -> "120 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/conv2d_0"; +"120 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[40]/conv2d_0" -> "123 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[41]/batch_norm_0"; +"121 basenet.41.weight" -> "123 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[41]/batch_norm_0"; +"122 basenet.41.bias" -> "123 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[41]/batch_norm_0"; +"123 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[41]/batch_norm_0" -> "124 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/relu__0"; +"124 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/relu__0" -> "125 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0"; +"125 SSD_VGG/MultiOutputSequential[basenet]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" -> "126 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[43]/max_pool2d_0"; +"126 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[43]/max_pool2d_0" -> "130 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/conv2d_0"; +"127 basenet.44.weight" -> "129 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/SymmetricQuantizer/symmetric_quantize_0"; +"128 basenet.44.bias" -> "130 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/conv2d_0"; +"129 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/SymmetricQuantizer/symmetric_quantize_0" -> "130 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/conv2d_0"; +"130 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[44]/conv2d_0" -> "133 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[45]/batch_norm_0"; +"131 basenet.45.weight" -> "133 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[45]/batch_norm_0"; +"132 basenet.45.bias" -> "133 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[45]/batch_norm_0"; +"133 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[45]/batch_norm_0" -> "134 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/relu__0"; +"134 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/relu__0" -> "135 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/SymmetricQuantizer/symmetric_quantize_0"; +"135 SSD_VGG/MultiOutputSequential[basenet]/ReLU[46]/SymmetricQuantizer/symmetric_quantize_0" -> "139 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/conv2d_0"; +"136 basenet.47.weight" -> "138 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/SymmetricQuantizer/symmetric_quantize_0"; +"137 basenet.47.bias" -> "139 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/conv2d_0"; +"138 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/SymmetricQuantizer/symmetric_quantize_0" -> "139 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/conv2d_0"; +"139 SSD_VGG/MultiOutputSequential[basenet]/Conv2d[47]/conv2d_0" -> "142 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[48]/batch_norm_0"; +"140 basenet.48.weight" -> "142 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[48]/batch_norm_0"; +"141 basenet.48.bias" -> "142 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[48]/batch_norm_0"; +"142 SSD_VGG/MultiOutputSequential[basenet]/BatchNorm2d[48]/batch_norm_0" -> "143 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/relu__0"; +"143 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/relu__0" -> "144 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0"; +"144 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" -> "166 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/conv2d_0"; +"144 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" -> "250 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0"; +"144 SSD_VGG/MultiOutputSequential[basenet]/ReLU[49]/SymmetricQuantizer/symmetric_quantize_0" -> "254 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0"; +"145 SSD_VGG/L2Norm[L2Norm]/pow_0" -> "146 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0"; +"146 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_0" -> "147 SSD_VGG/L2Norm[L2Norm]/sum_0"; +"147 SSD_VGG/L2Norm[L2Norm]/sum_0" -> "148 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_1"; +"148 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_1" -> "149 SSD_VGG/L2Norm[L2Norm]/sqrt_0"; +"149 SSD_VGG/L2Norm[L2Norm]/sqrt_0" -> "150 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_2"; +"150 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_2" -> "151 SSD_VGG/L2Norm[L2Norm]/__add___0"; +"151 SSD_VGG/L2Norm[L2Norm]/__add___0" -> "152 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_3"; +"152 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_3" -> "153 SSD_VGG/L2Norm[L2Norm]/div_0"; +"153 SSD_VGG/L2Norm[L2Norm]/div_0" -> "158 SSD_VGG/L2Norm[L2Norm]/expand_as_0"; +"153 SSD_VGG/L2Norm[L2Norm]/div_0" -> "160 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_5"; +"154 L2Norm.weight" -> "155 SSD_VGG/L2Norm[L2Norm]/unsqueeze_0"; +"155 SSD_VGG/L2Norm[L2Norm]/unsqueeze_0" -> "156 SSD_VGG/L2Norm[L2Norm]/unsqueeze_1"; +"156 SSD_VGG/L2Norm[L2Norm]/unsqueeze_1" -> "157 SSD_VGG/L2Norm[L2Norm]/unsqueeze_2"; +"157 SSD_VGG/L2Norm[L2Norm]/unsqueeze_2" -> "158 SSD_VGG/L2Norm[L2Norm]/expand_as_0"; +"158 SSD_VGG/L2Norm[L2Norm]/expand_as_0" -> "159 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_4"; +"159 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_4" -> "161 SSD_VGG/L2Norm[L2Norm]/__mul___0"; +"160 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_5" -> "161 SSD_VGG/L2Norm[L2Norm]/__mul___0"; +"161 SSD_VGG/L2Norm[L2Norm]/__mul___0" -> "162 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_6"; +"162 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_6" -> "238 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0"; +"162 SSD_VGG/L2Norm[L2Norm]/SymmetricQuantizer/symmetric_quantize_6" -> "242 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0"; +"163 extras.0.weight" -> "165 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"164 extras.0.bias" -> "166 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/conv2d_0"; +"165 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "166 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/conv2d_0"; +"166 SSD_VGG/MultiOutputSequential[extras]/Conv2d[0]/conv2d_0" -> "169 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[1]/batch_norm_0"; +"167 extras.1.weight" -> "169 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[1]/batch_norm_0"; +"168 extras.1.bias" -> "169 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[1]/batch_norm_0"; +"169 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[1]/batch_norm_0" -> "170 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/relu__0"; +"170 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/relu__0" -> "171 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"171 SSD_VGG/MultiOutputSequential[extras]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "175 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/conv2d_0"; +"172 extras.3.weight" -> "174 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"173 extras.3.bias" -> "175 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/conv2d_0"; +"174 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "175 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/conv2d_0"; +"175 SSD_VGG/MultiOutputSequential[extras]/Conv2d[3]/conv2d_0" -> "178 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[4]/batch_norm_0"; +"176 extras.4.weight" -> "178 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[4]/batch_norm_0"; +"177 extras.4.bias" -> "178 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[4]/batch_norm_0"; +"178 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[4]/batch_norm_0" -> "179 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/relu__0"; +"179 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/relu__0" -> "180 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"180 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "184 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/conv2d_0"; +"180 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "262 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0"; +"180 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "266 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0"; +"181 extras.6.weight" -> "183 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0"; +"182 extras.6.bias" -> "184 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/conv2d_0"; +"183 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/SymmetricQuantizer/symmetric_quantize_0" -> "184 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/conv2d_0"; +"184 SSD_VGG/MultiOutputSequential[extras]/Conv2d[6]/conv2d_0" -> "187 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[7]/batch_norm_0"; +"185 extras.7.weight" -> "187 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[7]/batch_norm_0"; +"186 extras.7.bias" -> "187 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[7]/batch_norm_0"; +"187 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[7]/batch_norm_0" -> "188 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/relu__0"; +"188 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/relu__0" -> "189 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0"; +"189 SSD_VGG/MultiOutputSequential[extras]/ReLU[8]/SymmetricQuantizer/symmetric_quantize_0" -> "193 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/conv2d_0"; +"190 extras.9.weight" -> "192 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/SymmetricQuantizer/symmetric_quantize_0"; +"191 extras.9.bias" -> "193 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/conv2d_0"; +"192 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/SymmetricQuantizer/symmetric_quantize_0" -> "193 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/conv2d_0"; +"193 SSD_VGG/MultiOutputSequential[extras]/Conv2d[9]/conv2d_0" -> "196 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[10]/batch_norm_0"; +"194 extras.10.weight" -> "196 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[10]/batch_norm_0"; +"195 extras.10.bias" -> "196 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[10]/batch_norm_0"; +"196 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[10]/batch_norm_0" -> "197 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/relu__0"; +"197 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/relu__0" -> "198 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0"; +"198 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "202 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/conv2d_0"; +"198 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "274 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0"; +"198 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/SymmetricQuantizer/symmetric_quantize_0" -> "278 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0"; +"199 extras.12.weight" -> "201 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/SymmetricQuantizer/symmetric_quantize_0"; +"200 extras.12.bias" -> "202 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/conv2d_0"; +"201 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/SymmetricQuantizer/symmetric_quantize_0" -> "202 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/conv2d_0"; +"202 SSD_VGG/MultiOutputSequential[extras]/Conv2d[12]/conv2d_0" -> "205 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[13]/batch_norm_0"; +"203 extras.13.weight" -> "205 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[13]/batch_norm_0"; +"204 extras.13.bias" -> "205 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[13]/batch_norm_0"; +"205 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[13]/batch_norm_0" -> "206 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/relu__0"; +"206 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/relu__0" -> "207 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/SymmetricQuantizer/symmetric_quantize_0"; +"207 SSD_VGG/MultiOutputSequential[extras]/ReLU[14]/SymmetricQuantizer/symmetric_quantize_0" -> "211 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/conv2d_0"; +"208 extras.15.weight" -> "210 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/SymmetricQuantizer/symmetric_quantize_0"; +"209 extras.15.bias" -> "211 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/conv2d_0"; +"210 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/SymmetricQuantizer/symmetric_quantize_0" -> "211 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/conv2d_0"; +"211 SSD_VGG/MultiOutputSequential[extras]/Conv2d[15]/conv2d_0" -> "214 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[16]/batch_norm_0"; +"212 extras.16.weight" -> "214 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[16]/batch_norm_0"; +"213 extras.16.bias" -> "214 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[16]/batch_norm_0"; +"214 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[16]/batch_norm_0" -> "215 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/relu__0"; +"215 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/relu__0" -> "216 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0"; +"216 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" -> "220 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/conv2d_0"; +"216 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" -> "286 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0"; +"216 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/SymmetricQuantizer/symmetric_quantize_0" -> "290 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0"; +"217 extras.18.weight" -> "219 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/SymmetricQuantizer/symmetric_quantize_0"; +"218 extras.18.bias" -> "220 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/conv2d_0"; +"219 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/SymmetricQuantizer/symmetric_quantize_0" -> "220 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/conv2d_0"; +"220 SSD_VGG/MultiOutputSequential[extras]/Conv2d[18]/conv2d_0" -> "223 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[19]/batch_norm_0"; +"221 extras.19.weight" -> "223 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[19]/batch_norm_0"; +"222 extras.19.bias" -> "223 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[19]/batch_norm_0"; +"223 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[19]/batch_norm_0" -> "224 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/relu__0"; +"224 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/relu__0" -> "225 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/SymmetricQuantizer/symmetric_quantize_0"; +"225 SSD_VGG/MultiOutputSequential[extras]/ReLU[20]/SymmetricQuantizer/symmetric_quantize_0" -> "229 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/conv2d_0"; +"226 extras.21.weight" -> "228 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/SymmetricQuantizer/symmetric_quantize_0"; +"227 extras.21.bias" -> "229 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/conv2d_0"; +"228 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/SymmetricQuantizer/symmetric_quantize_0" -> "229 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/conv2d_0"; +"229 SSD_VGG/MultiOutputSequential[extras]/Conv2d[21]/conv2d_0" -> "232 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[22]/batch_norm_0"; +"230 extras.22.weight" -> "232 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[22]/batch_norm_0"; +"231 extras.22.bias" -> "232 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[22]/batch_norm_0"; +"232 SSD_VGG/MultiOutputSequential[extras]/BatchNorm2d[22]/batch_norm_0" -> "233 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/relu__0"; +"233 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/relu__0" -> "234 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0"; +"234 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0" -> "298 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0"; +"234 SSD_VGG/MultiOutputSequential[extras]/ReLU[23]/SymmetricQuantizer/symmetric_quantize_0" -> "302 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0"; +"235 detection_head.heads.0.loc.weight" -> "237 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"236 detection_head.heads.0.loc.bias" -> "238 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0"; +"237 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "238 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0"; +"238 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[loc]/conv2d_0" -> "243 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0"; +"239 detection_head.heads.0.conf.weight" -> "241 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"240 detection_head.heads.0.conf.bias" -> "242 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0"; +"241 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "242 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0"; +"242 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/Conv2d[conf]/conv2d_0" -> "245 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1"; +"243 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_0" -> "244 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0"; +"244 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_0" -> "307 SSD_VGG/SSDDetectionOutput[detection_head]/view_0"; +"245 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/permute_1" -> "246 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1"; +"246 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/contiguous_1" -> "314 SSD_VGG/SSDDetectionOutput[detection_head]/view_6"; +"247 detection_head.heads.1.loc.weight" -> "249 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"248 detection_head.heads.1.loc.bias" -> "250 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0"; +"249 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "250 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0"; +"250 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[loc]/conv2d_0" -> "255 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0"; +"251 detection_head.heads.1.conf.weight" -> "253 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"252 detection_head.heads.1.conf.bias" -> "254 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0"; +"253 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "254 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0"; +"254 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/Conv2d[conf]/conv2d_0" -> "257 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1"; +"255 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_0" -> "256 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0"; +"256 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_0" -> "308 SSD_VGG/SSDDetectionOutput[detection_head]/view_1"; +"257 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/permute_1" -> "258 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1"; +"258 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/contiguous_1" -> "315 SSD_VGG/SSDDetectionOutput[detection_head]/view_7"; +"259 detection_head.heads.2.loc.weight" -> "261 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"260 detection_head.heads.2.loc.bias" -> "262 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0"; +"261 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "262 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0"; +"262 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[loc]/conv2d_0" -> "267 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0"; +"263 detection_head.heads.2.conf.weight" -> "265 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"264 detection_head.heads.2.conf.bias" -> "266 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0"; +"265 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "266 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0"; +"266 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/Conv2d[conf]/conv2d_0" -> "269 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1"; +"267 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_0" -> "268 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0"; +"268 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_0" -> "309 SSD_VGG/SSDDetectionOutput[detection_head]/view_2"; +"269 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/permute_1" -> "270 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1"; +"270 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/contiguous_1" -> "316 SSD_VGG/SSDDetectionOutput[detection_head]/view_8"; +"271 detection_head.heads.3.loc.weight" -> "273 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"272 detection_head.heads.3.loc.bias" -> "274 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0"; +"273 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "274 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0"; +"274 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[loc]/conv2d_0" -> "279 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0"; +"275 detection_head.heads.3.conf.weight" -> "277 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"276 detection_head.heads.3.conf.bias" -> "278 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0"; +"277 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "278 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0"; +"278 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/Conv2d[conf]/conv2d_0" -> "281 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1"; +"279 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_0" -> "280 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0"; +"280 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_0" -> "310 SSD_VGG/SSDDetectionOutput[detection_head]/view_3"; +"281 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/permute_1" -> "282 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1"; +"282 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/contiguous_1" -> "317 SSD_VGG/SSDDetectionOutput[detection_head]/view_9"; +"283 detection_head.heads.4.loc.weight" -> "285 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"284 detection_head.heads.4.loc.bias" -> "286 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0"; +"285 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "286 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0"; +"286 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[loc]/conv2d_0" -> "291 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0"; +"287 detection_head.heads.4.conf.weight" -> "289 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"288 detection_head.heads.4.conf.bias" -> "290 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0"; +"289 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "290 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0"; +"290 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/Conv2d[conf]/conv2d_0" -> "293 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1"; +"291 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_0" -> "292 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0"; +"292 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_0" -> "311 SSD_VGG/SSDDetectionOutput[detection_head]/view_4"; +"293 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/permute_1" -> "294 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1"; +"294 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/contiguous_1" -> "318 SSD_VGG/SSDDetectionOutput[detection_head]/view_10"; +"295 detection_head.heads.5.loc.weight" -> "297 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0"; +"296 detection_head.heads.5.loc.bias" -> "298 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0"; +"297 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/SymmetricQuantizer/symmetric_quantize_0" -> "298 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0"; +"298 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[loc]/conv2d_0" -> "303 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0"; +"299 detection_head.heads.5.conf.weight" -> "301 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0"; +"300 detection_head.heads.5.conf.bias" -> "302 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0"; +"301 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/SymmetricQuantizer/symmetric_quantize_0" -> "302 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0"; +"302 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/Conv2d[conf]/conv2d_0" -> "305 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1"; +"303 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_0" -> "304 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0"; +"304 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_0" -> "312 SSD_VGG/SSDDetectionOutput[detection_head]/view_5"; +"305 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/permute_1" -> "306 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1"; +"306 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/contiguous_1" -> "319 SSD_VGG/SSDDetectionOutput[detection_head]/view_11"; +"307 SSD_VGG/SSDDetectionOutput[detection_head]/view_0" -> "313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; +"308 SSD_VGG/SSDDetectionOutput[detection_head]/view_1" -> "313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; +"309 SSD_VGG/SSDDetectionOutput[detection_head]/view_2" -> "313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; +"310 SSD_VGG/SSDDetectionOutput[detection_head]/view_3" -> "313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; +"311 SSD_VGG/SSDDetectionOutput[detection_head]/view_4" -> "313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; +"312 SSD_VGG/SSDDetectionOutput[detection_head]/view_5" -> "313 SSD_VGG/SSDDetectionOutput[detection_head]/cat_0"; +"314 SSD_VGG/SSDDetectionOutput[detection_head]/view_6" -> "320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; +"315 SSD_VGG/SSDDetectionOutput[detection_head]/view_7" -> "320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; +"316 SSD_VGG/SSDDetectionOutput[detection_head]/view_8" -> "320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; +"317 SSD_VGG/SSDDetectionOutput[detection_head]/view_9" -> "320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; +"318 SSD_VGG/SSDDetectionOutput[detection_head]/view_10" -> "320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; +"319 SSD_VGG/SSDDetectionOutput[detection_head]/view_11" -> "320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1"; +"320 SSD_VGG/SSDDetectionOutput[detection_head]/cat_1" -> "321 SSD_VGG/SSDDetectionOutput[detection_head]/view_12"; +"321 SSD_VGG/SSDDetectionOutput[detection_head]/view_12" -> "322 SSD_VGG/SSDDetectionOutput[detection_head]/softmax_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/unet.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/unet.dot index a90f67546d9..e3295ecdaab 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/unet.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/unet.dot @@ -1,243 +1,407 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=4, type=batch_norm]; -"5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/relu_0" [id=5, type=relu]; -"6 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=8, type=conv2d]; -"9 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=9, type=batch_norm]; -"10 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/relu_0" [id=10, type=relu]; -"11 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 UNet/max_pool2d_0" [id=12, type=max_pool2d]; -"13 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; -"14 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=14, type=conv2d]; -"15 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=15, type=batch_norm]; -"16 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/relu_0" [id=16, type=relu]; -"17 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=17, type=symmetric_quantize]; -"18 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=18, type=symmetric_quantize]; -"19 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=19, type=conv2d]; -"20 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=20, type=batch_norm]; -"21 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/relu_0" [id=21, type=relu]; -"22 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=22, type=symmetric_quantize]; -"23 UNet/max_pool2d_1" [id=23, type=max_pool2d]; -"24 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=25, type=conv2d]; -"26 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=26, type=batch_norm]; -"27 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/relu_0" [id=27, type=relu]; -"28 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; -"29 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=29, type=symmetric_quantize]; -"30 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=30, type=conv2d]; -"31 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=31, type=batch_norm]; -"32 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/relu_0" [id=32, type=relu]; -"33 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; -"34 UNet/max_pool2d_2" [id=34, type=max_pool2d]; -"35 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=35, type=symmetric_quantize]; -"36 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=36, type=conv2d]; -"37 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=37, type=batch_norm]; -"38 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/relu_0" [id=38, type=relu]; -"39 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=39, type=symmetric_quantize]; -"40 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=40, type=symmetric_quantize]; -"41 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=41, type=conv2d]; -"42 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=42, type=batch_norm]; -"43 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/relu_0" [id=43, type=relu]; -"44 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 UNet/max_pool2d_3" [id=45, type=max_pool2d]; -"46 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=46, type=symmetric_quantize]; -"47 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=47, type=conv2d]; -"48 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=48, type=batch_norm]; -"49 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/relu_0" [id=49, type=relu]; -"50 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; -"51 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; -"52 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=52, type=conv2d]; -"53 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=53, type=batch_norm]; -"54 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/relu_0" [id=54, type=relu]; -"55 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=55, type=symmetric_quantize]; -"56 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; -"57 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/conv_transpose2d_0" [id=57, type=conv_transpose2d]; -"58 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=58, type=symmetric_quantize]; -"59 UNet/ModuleList[up_path]/UNetUpBlock[0]/__getitem___0" [id=59, type=__getitem__]; -"60 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0" [id=60, type=cat]; -"61 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; -"62 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=62, type=conv2d]; -"63 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=63, type=batch_norm]; -"64 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=64, type=relu]; -"65 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=66, type=symmetric_quantize]; -"67 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=67, type=conv2d]; -"68 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=68, type=batch_norm]; -"69 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=69, type=relu]; -"70 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; -"71 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=71, type=symmetric_quantize]; -"72 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/conv_transpose2d_0" [id=72, type=conv_transpose2d]; -"73 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 UNet/ModuleList[up_path]/UNetUpBlock[1]/__getitem___0" [id=74, type=__getitem__]; -"75 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0" [id=75, type=cat]; -"76 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=76, type=symmetric_quantize]; -"77 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=77, type=conv2d]; -"78 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=78, type=batch_norm]; -"79 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=79, type=relu]; -"80 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; -"81 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; -"82 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=82, type=conv2d]; -"83 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=83, type=batch_norm]; -"84 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=84, type=relu]; -"85 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; -"86 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=86, type=symmetric_quantize]; -"87 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/conv_transpose2d_0" [id=87, type=conv_transpose2d]; -"88 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; -"89 UNet/ModuleList[up_path]/UNetUpBlock[2]/__getitem___0" [id=89, type=__getitem__]; -"90 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0" [id=90, type=cat]; -"91 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=91, type=symmetric_quantize]; -"92 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=92, type=conv2d]; -"93 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=93, type=batch_norm]; -"94 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=94, type=relu]; -"95 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=95, type=symmetric_quantize]; -"96 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=96, type=symmetric_quantize]; -"97 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=97, type=conv2d]; -"98 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=98, type=batch_norm]; -"99 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=99, type=relu]; -"100 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=100, type=symmetric_quantize]; -"101 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=101, type=symmetric_quantize]; -"102 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/conv_transpose2d_0" [id=102, type=conv_transpose2d]; -"103 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=103, type=symmetric_quantize]; -"104 UNet/ModuleList[up_path]/UNetUpBlock[3]/__getitem___0" [id=104, type=__getitem__]; -"105 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0" [id=105, type=cat]; -"106 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=106, type=symmetric_quantize]; -"107 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" [id=107, type=conv2d]; -"108 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" [id=108, type=batch_norm]; -"109 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=109, type=relu]; -"110 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=110, type=symmetric_quantize]; -"111 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; -"112 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" [id=112, type=conv2d]; -"113 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" [id=113, type=batch_norm]; -"114 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=114, type=relu]; -"115 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=115, type=symmetric_quantize]; -"116 UNet/NNCFConv2d[last]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=116, type=symmetric_quantize]; -"117 UNet/NNCFConv2d[last]/conv2d_0" [id=117, type=conv2d]; -"118 /nncf_model_output_0" [id=118, type=nncf_model_output]; +"2 down_path.0.block.0.weight" [id=2, type=nncf_model_const]; +"3 down_path.0.block.0.bias" [id=3, type=nncf_model_const]; +"4 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/conv2d_0" [id=5, type=conv2d]; +"6 down_path.0.block.1.weight" [id=6, type=nncf_model_const]; +"7 down_path.0.block.1.bias" [id=7, type=nncf_model_const]; +"8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=8, type=batch_norm]; +"9 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/relu_0" [id=9, type=relu]; +"10 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; +"11 down_path.0.block.3.weight" [id=11, type=nncf_model_const]; +"12 down_path.0.block.3.bias" [id=12, type=nncf_model_const]; +"13 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/conv2d_0" [id=14, type=conv2d]; +"15 down_path.0.block.4.weight" [id=15, type=nncf_model_const]; +"16 down_path.0.block.4.bias" [id=16, type=nncf_model_const]; +"17 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=17, type=batch_norm]; +"18 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/relu_0" [id=18, type=relu]; +"19 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; +"20 UNet/max_pool2d_0" [id=20, type=max_pool2d]; +"21 down_path.1.block.0.weight" [id=21, type=nncf_model_const]; +"22 down_path.1.block.0.bias" [id=22, type=nncf_model_const]; +"23 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; +"24 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/conv2d_0" [id=24, type=conv2d]; +"25 down_path.1.block.1.weight" [id=25, type=nncf_model_const]; +"26 down_path.1.block.1.bias" [id=26, type=nncf_model_const]; +"27 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=27, type=batch_norm]; +"28 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/relu_0" [id=28, type=relu]; +"29 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=29, type=symmetric_quantize]; +"30 down_path.1.block.3.weight" [id=30, type=nncf_model_const]; +"31 down_path.1.block.3.bias" [id=31, type=nncf_model_const]; +"32 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=32, type=symmetric_quantize]; +"33 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/conv2d_0" [id=33, type=conv2d]; +"34 down_path.1.block.4.weight" [id=34, type=nncf_model_const]; +"35 down_path.1.block.4.bias" [id=35, type=nncf_model_const]; +"36 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=36, type=batch_norm]; +"37 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/relu_0" [id=37, type=relu]; +"38 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 UNet/max_pool2d_1" [id=39, type=max_pool2d]; +"40 down_path.2.block.0.weight" [id=40, type=nncf_model_const]; +"41 down_path.2.block.0.bias" [id=41, type=nncf_model_const]; +"42 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/conv2d_0" [id=43, type=conv2d]; +"44 down_path.2.block.1.weight" [id=44, type=nncf_model_const]; +"45 down_path.2.block.1.bias" [id=45, type=nncf_model_const]; +"46 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=46, type=batch_norm]; +"47 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/relu_0" [id=47, type=relu]; +"48 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 down_path.2.block.3.weight" [id=49, type=nncf_model_const]; +"50 down_path.2.block.3.bias" [id=50, type=nncf_model_const]; +"51 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/conv2d_0" [id=52, type=conv2d]; +"53 down_path.2.block.4.weight" [id=53, type=nncf_model_const]; +"54 down_path.2.block.4.bias" [id=54, type=nncf_model_const]; +"55 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=55, type=batch_norm]; +"56 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/relu_0" [id=56, type=relu]; +"57 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=57, type=symmetric_quantize]; +"58 UNet/max_pool2d_2" [id=58, type=max_pool2d]; +"59 down_path.3.block.0.weight" [id=59, type=nncf_model_const]; +"60 down_path.3.block.0.bias" [id=60, type=nncf_model_const]; +"61 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=61, type=symmetric_quantize]; +"62 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/conv2d_0" [id=62, type=conv2d]; +"63 down_path.3.block.1.weight" [id=63, type=nncf_model_const]; +"64 down_path.3.block.1.bias" [id=64, type=nncf_model_const]; +"65 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=65, type=batch_norm]; +"66 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/relu_0" [id=66, type=relu]; +"67 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=67, type=symmetric_quantize]; +"68 down_path.3.block.3.weight" [id=68, type=nncf_model_const]; +"69 down_path.3.block.3.bias" [id=69, type=nncf_model_const]; +"70 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/conv2d_0" [id=71, type=conv2d]; +"72 down_path.3.block.4.weight" [id=72, type=nncf_model_const]; +"73 down_path.3.block.4.bias" [id=73, type=nncf_model_const]; +"74 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=74, type=batch_norm]; +"75 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/relu_0" [id=75, type=relu]; +"76 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; +"77 UNet/max_pool2d_3" [id=77, type=max_pool2d]; +"78 down_path.4.block.0.weight" [id=78, type=nncf_model_const]; +"79 down_path.4.block.0.bias" [id=79, type=nncf_model_const]; +"80 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/conv2d_0" [id=81, type=conv2d]; +"82 down_path.4.block.1.weight" [id=82, type=nncf_model_const]; +"83 down_path.4.block.1.bias" [id=83, type=nncf_model_const]; +"84 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=84, type=batch_norm]; +"85 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/relu_0" [id=85, type=relu]; +"86 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=86, type=symmetric_quantize]; +"87 down_path.4.block.3.weight" [id=87, type=nncf_model_const]; +"88 down_path.4.block.3.bias" [id=88, type=nncf_model_const]; +"89 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=89, type=symmetric_quantize]; +"90 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/conv2d_0" [id=90, type=conv2d]; +"91 down_path.4.block.4.weight" [id=91, type=nncf_model_const]; +"92 down_path.4.block.4.bias" [id=92, type=nncf_model_const]; +"93 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=93, type=batch_norm]; +"94 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/relu_0" [id=94, type=relu]; +"95 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=95, type=symmetric_quantize]; +"96 up_path.0.up.weight" [id=96, type=nncf_model_const]; +"97 up_path.0.up.bias" [id=97, type=nncf_model_const]; +"98 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=98, type=symmetric_quantize]; +"99 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/conv_transpose2d_0" [id=99, type=conv_transpose2d]; +"100 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" [id=100, type=symmetric_quantize]; +"101 UNet/ModuleList[up_path]/UNetUpBlock[0]/__getitem___0" [id=101, type=__getitem__]; +"102 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0" [id=102, type=cat]; +"103 up_path.0.conv_block.block.0.weight" [id=103, type=nncf_model_const]; +"104 up_path.0.conv_block.block.0.bias" [id=104, type=nncf_model_const]; +"105 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; +"106 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" [id=106, type=conv2d]; +"107 up_path.0.conv_block.block.1.weight" [id=107, type=nncf_model_const]; +"108 up_path.0.conv_block.block.1.bias" [id=108, type=nncf_model_const]; +"109 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=109, type=batch_norm]; +"110 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=110, type=relu]; +"111 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 up_path.0.conv_block.block.3.weight" [id=112, type=nncf_model_const]; +"113 up_path.0.conv_block.block.3.bias" [id=113, type=nncf_model_const]; +"114 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" [id=115, type=conv2d]; +"116 up_path.0.conv_block.block.4.weight" [id=116, type=nncf_model_const]; +"117 up_path.0.conv_block.block.4.bias" [id=117, type=nncf_model_const]; +"118 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=118, type=batch_norm]; +"119 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=119, type=relu]; +"120 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 up_path.1.up.weight" [id=121, type=nncf_model_const]; +"122 up_path.1.up.bias" [id=122, type=nncf_model_const]; +"123 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/conv_transpose2d_0" [id=124, type=conv_transpose2d]; +"125 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" [id=125, type=symmetric_quantize]; +"126 UNet/ModuleList[up_path]/UNetUpBlock[1]/__getitem___0" [id=126, type=__getitem__]; +"127 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0" [id=127, type=cat]; +"128 up_path.1.conv_block.block.0.weight" [id=128, type=nncf_model_const]; +"129 up_path.1.conv_block.block.0.bias" [id=129, type=nncf_model_const]; +"130 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=130, type=symmetric_quantize]; +"131 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" [id=131, type=conv2d]; +"132 up_path.1.conv_block.block.1.weight" [id=132, type=nncf_model_const]; +"133 up_path.1.conv_block.block.1.bias" [id=133, type=nncf_model_const]; +"134 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=134, type=batch_norm]; +"135 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=135, type=relu]; +"136 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=136, type=symmetric_quantize]; +"137 up_path.1.conv_block.block.3.weight" [id=137, type=nncf_model_const]; +"138 up_path.1.conv_block.block.3.bias" [id=138, type=nncf_model_const]; +"139 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" [id=140, type=conv2d]; +"141 up_path.1.conv_block.block.4.weight" [id=141, type=nncf_model_const]; +"142 up_path.1.conv_block.block.4.bias" [id=142, type=nncf_model_const]; +"143 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=143, type=batch_norm]; +"144 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=144, type=relu]; +"145 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 up_path.2.up.weight" [id=146, type=nncf_model_const]; +"147 up_path.2.up.bias" [id=147, type=nncf_model_const]; +"148 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=148, type=symmetric_quantize]; +"149 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/conv_transpose2d_0" [id=149, type=conv_transpose2d]; +"150 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" [id=150, type=symmetric_quantize]; +"151 UNet/ModuleList[up_path]/UNetUpBlock[2]/__getitem___0" [id=151, type=__getitem__]; +"152 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0" [id=152, type=cat]; +"153 up_path.2.conv_block.block.0.weight" [id=153, type=nncf_model_const]; +"154 up_path.2.conv_block.block.0.bias" [id=154, type=nncf_model_const]; +"155 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; +"156 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" [id=156, type=conv2d]; +"157 up_path.2.conv_block.block.1.weight" [id=157, type=nncf_model_const]; +"158 up_path.2.conv_block.block.1.bias" [id=158, type=nncf_model_const]; +"159 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=159, type=batch_norm]; +"160 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=160, type=relu]; +"161 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 up_path.2.conv_block.block.3.weight" [id=162, type=nncf_model_const]; +"163 up_path.2.conv_block.block.3.bias" [id=163, type=nncf_model_const]; +"164 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=164, type=symmetric_quantize]; +"165 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" [id=165, type=conv2d]; +"166 up_path.2.conv_block.block.4.weight" [id=166, type=nncf_model_const]; +"167 up_path.2.conv_block.block.4.bias" [id=167, type=nncf_model_const]; +"168 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=168, type=batch_norm]; +"169 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=169, type=relu]; +"170 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=170, type=symmetric_quantize]; +"171 up_path.3.up.weight" [id=171, type=nncf_model_const]; +"172 up_path.3.up.bias" [id=172, type=nncf_model_const]; +"173 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" [id=173, type=symmetric_quantize]; +"174 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/conv_transpose2d_0" [id=174, type=conv_transpose2d]; +"175 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" [id=175, type=symmetric_quantize]; +"176 UNet/ModuleList[up_path]/UNetUpBlock[3]/__getitem___0" [id=176, type=__getitem__]; +"177 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0" [id=177, type=cat]; +"178 up_path.3.conv_block.block.0.weight" [id=178, type=nncf_model_const]; +"179 up_path.3.conv_block.block.0.bias" [id=179, type=nncf_model_const]; +"180 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=180, type=symmetric_quantize]; +"181 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" [id=181, type=conv2d]; +"182 up_path.3.conv_block.block.1.weight" [id=182, type=nncf_model_const]; +"183 up_path.3.conv_block.block.1.bias" [id=183, type=nncf_model_const]; +"184 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" [id=184, type=batch_norm]; +"185 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" [id=185, type=relu]; +"186 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 up_path.3.conv_block.block.3.weight" [id=187, type=nncf_model_const]; +"188 up_path.3.conv_block.block.3.bias" [id=188, type=nncf_model_const]; +"189 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=189, type=symmetric_quantize]; +"190 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" [id=190, type=conv2d]; +"191 up_path.3.conv_block.block.4.weight" [id=191, type=nncf_model_const]; +"192 up_path.3.conv_block.block.4.bias" [id=192, type=nncf_model_const]; +"193 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" [id=193, type=batch_norm]; +"194 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" [id=194, type=relu]; +"195 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 last.weight" [id=196, type=nncf_model_const]; +"197 last.bias" [id=197, type=nncf_model_const]; +"198 UNet/Conv2d[last]/SymmetricQuantizer/symmetric_quantize_0" [id=198, type=symmetric_quantize]; +"199 UNet/Conv2d[last]/conv2d_0" [id=199, type=conv2d]; +"200 /nncf_model_output_0" [id=200, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"2 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"3 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "4 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"4 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/relu_0"; -"5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/relu_0" -> "6 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"6 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"7 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "9 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"9 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "10 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/relu_0"; -"10 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/relu_0" -> "11 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"11 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "12 UNet/max_pool2d_0"; -"11 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "104 UNet/ModuleList[up_path]/UNetUpBlock[3]/__getitem___0"; -"12 UNet/max_pool2d_0" -> "14 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"13 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"14 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "15 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"15 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "16 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/relu_0"; -"16 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/relu_0" -> "17 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"17 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "19 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"18 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "19 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"19 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "20 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"20 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "21 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/relu_0"; -"21 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/relu_0" -> "22 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"22 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "23 UNet/max_pool2d_1"; -"22 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "89 UNet/ModuleList[up_path]/UNetUpBlock[2]/__getitem___0"; -"23 UNet/max_pool2d_1" -> "25 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"24 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "25 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"25 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "26 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"26 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "27 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/relu_0"; -"27 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/relu_0" -> "28 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"28 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "30 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"29 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "30 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"30 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "31 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"31 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "32 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/relu_0"; -"32 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/relu_0" -> "33 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"33 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "34 UNet/max_pool2d_2"; -"33 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "74 UNet/ModuleList[up_path]/UNetUpBlock[1]/__getitem___0"; -"34 UNet/max_pool2d_2" -> "36 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"35 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "36 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"36 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "37 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"37 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "38 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/relu_0"; -"38 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/relu_0" -> "39 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"39 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "41 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"40 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "41 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"41 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "42 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"42 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "43 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/relu_0"; -"43 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/relu_0" -> "44 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"44 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "45 UNet/max_pool2d_3"; -"44 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "59 UNet/ModuleList[up_path]/UNetUpBlock[0]/__getitem___0"; -"45 UNet/max_pool2d_3" -> "47 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"46 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "47 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"47 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "48 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"48 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "49 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/relu_0"; -"49 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/relu_0" -> "50 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"50 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "52 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"51 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"52 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "53 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"53 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "54 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/relu_0"; -"54 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/relu_0" -> "55 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"55 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "57 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"56 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"57 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/conv_transpose2d_0" -> "58 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; -"58 UNet/ModuleList[up_path]/UNetUpBlock[0]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "60 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0"; -"59 UNet/ModuleList[up_path]/UNetUpBlock[0]/__getitem___0" -> "60 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0"; -"60 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0" -> "62 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"61 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"62 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "63 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"63 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "64 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; -"64 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "65 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"65 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "67 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"66 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "67 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"67 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "68 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"68 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "69 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; -"69 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "70 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"70 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "72 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"71 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "72 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"72 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/conv_transpose2d_0" -> "73 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; -"73 UNet/ModuleList[up_path]/UNetUpBlock[1]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "75 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0"; -"74 UNet/ModuleList[up_path]/UNetUpBlock[1]/__getitem___0" -> "75 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0"; -"75 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0" -> "77 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"76 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "77 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"77 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "78 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"78 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "79 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; -"79 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "80 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"80 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "82 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"81 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"82 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "83 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"83 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "84 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; -"84 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "85 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"85 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "87 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"86 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "87 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"87 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/conv_transpose2d_0" -> "88 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; -"88 UNet/ModuleList[up_path]/UNetUpBlock[2]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "90 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0"; -"89 UNet/ModuleList[up_path]/UNetUpBlock[2]/__getitem___0" -> "90 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0"; -"90 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0" -> "92 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"91 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "92 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"92 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "93 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"93 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "94 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; -"94 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "95 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"95 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "97 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"96 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "97 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"97 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "98 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"98 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "99 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; -"99 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "100 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"100 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "102 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"101 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "102 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/conv_transpose2d_0"; -"102 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/conv_transpose2d_0" -> "103 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; -"103 UNet/ModuleList[up_path]/UNetUpBlock[3]/NNCFConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "105 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0"; -"104 UNet/ModuleList[up_path]/UNetUpBlock[3]/__getitem___0" -> "105 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0"; -"105 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0" -> "107 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"106 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "107 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0"; -"107 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[0]/conv2d_0" -> "108 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0"; -"108 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[1]/batch_norm_0" -> "109 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; -"109 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "110 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"110 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "112 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"111 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0"; -"112 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFConv2d[3]/conv2d_0" -> "113 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0"; -"113 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/NNCFBatchNorm2d[4]/batch_norm_0" -> "114 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; -"114 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "115 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"115 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "117 UNet/NNCFConv2d[last]/conv2d_0"; -"116 UNet/NNCFConv2d[last]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "117 UNet/NNCFConv2d[last]/conv2d_0"; -"117 UNet/NNCFConv2d[last]/conv2d_0" -> "118 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/conv2d_0"; +"2 down_path.0.block.0.weight" -> "4 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 down_path.0.block.0.bias" -> "5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/conv2d_0"; +"4 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/conv2d_0"; +"5 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[0]/conv2d_0" -> "8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"6 down_path.0.block.1.weight" -> "8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"7 down_path.0.block.1.bias" -> "8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"8 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "9 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/relu_0"; +"9 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/relu_0" -> "10 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"10 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "14 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/conv2d_0"; +"11 down_path.0.block.3.weight" -> "13 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"12 down_path.0.block.3.bias" -> "14 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/conv2d_0"; +"13 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "14 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/conv2d_0"; +"14 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/Conv2d[3]/conv2d_0" -> "17 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"15 down_path.0.block.4.weight" -> "17 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"16 down_path.0.block.4.bias" -> "17 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"17 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "18 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/relu_0"; +"18 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/relu_0" -> "19 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"19 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "20 UNet/max_pool2d_0"; +"19 UNet/ModuleList[down_path]/UNetConvBlock[0]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "176 UNet/ModuleList[up_path]/UNetUpBlock[3]/__getitem___0"; +"20 UNet/max_pool2d_0" -> "24 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/conv2d_0"; +"21 down_path.1.block.0.weight" -> "23 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"22 down_path.1.block.0.bias" -> "24 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/conv2d_0"; +"23 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "24 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/conv2d_0"; +"24 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[0]/conv2d_0" -> "27 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"25 down_path.1.block.1.weight" -> "27 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"26 down_path.1.block.1.bias" -> "27 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"27 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "28 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/relu_0"; +"28 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/relu_0" -> "29 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"29 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "33 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/conv2d_0"; +"30 down_path.1.block.3.weight" -> "32 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"31 down_path.1.block.3.bias" -> "33 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/conv2d_0"; +"32 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "33 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/conv2d_0"; +"33 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/Conv2d[3]/conv2d_0" -> "36 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"34 down_path.1.block.4.weight" -> "36 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"35 down_path.1.block.4.bias" -> "36 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"36 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "37 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/relu_0"; +"37 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/relu_0" -> "38 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"38 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "39 UNet/max_pool2d_1"; +"38 UNet/ModuleList[down_path]/UNetConvBlock[1]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "151 UNet/ModuleList[up_path]/UNetUpBlock[2]/__getitem___0"; +"39 UNet/max_pool2d_1" -> "43 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/conv2d_0"; +"40 down_path.2.block.0.weight" -> "42 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"41 down_path.2.block.0.bias" -> "43 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/conv2d_0"; +"42 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "43 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/conv2d_0"; +"43 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[0]/conv2d_0" -> "46 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"44 down_path.2.block.1.weight" -> "46 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"45 down_path.2.block.1.bias" -> "46 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"46 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "47 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/relu_0"; +"47 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/relu_0" -> "48 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"48 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "52 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/conv2d_0"; +"49 down_path.2.block.3.weight" -> "51 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"50 down_path.2.block.3.bias" -> "52 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/conv2d_0"; +"51 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "52 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/conv2d_0"; +"52 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/Conv2d[3]/conv2d_0" -> "55 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"53 down_path.2.block.4.weight" -> "55 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"54 down_path.2.block.4.bias" -> "55 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"55 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "56 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/relu_0"; +"56 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/relu_0" -> "57 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"57 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "58 UNet/max_pool2d_2"; +"57 UNet/ModuleList[down_path]/UNetConvBlock[2]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "126 UNet/ModuleList[up_path]/UNetUpBlock[1]/__getitem___0"; +"58 UNet/max_pool2d_2" -> "62 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/conv2d_0"; +"59 down_path.3.block.0.weight" -> "61 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"60 down_path.3.block.0.bias" -> "62 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/conv2d_0"; +"61 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "62 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/conv2d_0"; +"62 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[0]/conv2d_0" -> "65 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"63 down_path.3.block.1.weight" -> "65 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"64 down_path.3.block.1.bias" -> "65 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"65 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "66 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/relu_0"; +"66 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/relu_0" -> "67 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"67 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "71 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/conv2d_0"; +"68 down_path.3.block.3.weight" -> "70 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"69 down_path.3.block.3.bias" -> "71 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/conv2d_0"; +"70 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "71 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/conv2d_0"; +"71 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/Conv2d[3]/conv2d_0" -> "74 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"72 down_path.3.block.4.weight" -> "74 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"73 down_path.3.block.4.bias" -> "74 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"74 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "75 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/relu_0"; +"75 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/relu_0" -> "76 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"76 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "77 UNet/max_pool2d_3"; +"76 UNet/ModuleList[down_path]/UNetConvBlock[3]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "101 UNet/ModuleList[up_path]/UNetUpBlock[0]/__getitem___0"; +"77 UNet/max_pool2d_3" -> "81 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/conv2d_0"; +"78 down_path.4.block.0.weight" -> "80 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"79 down_path.4.block.0.bias" -> "81 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/conv2d_0"; +"80 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "81 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/conv2d_0"; +"81 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[0]/conv2d_0" -> "84 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"82 down_path.4.block.1.weight" -> "84 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"83 down_path.4.block.1.bias" -> "84 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"84 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "85 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/relu_0"; +"85 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/relu_0" -> "86 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"86 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "90 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/conv2d_0"; +"87 down_path.4.block.3.weight" -> "89 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"88 down_path.4.block.3.bias" -> "90 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/conv2d_0"; +"89 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "90 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/conv2d_0"; +"90 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/Conv2d[3]/conv2d_0" -> "93 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"91 down_path.4.block.4.weight" -> "93 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"92 down_path.4.block.4.bias" -> "93 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"93 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "94 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/relu_0"; +"94 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/relu_0" -> "95 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"95 UNet/ModuleList[down_path]/UNetConvBlock[4]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "99 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/conv_transpose2d_0"; +"96 up_path.0.up.weight" -> "98 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; +"97 up_path.0.up.bias" -> "99 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/conv_transpose2d_0"; +"98 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "99 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/conv_transpose2d_0"; +"99 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/conv_transpose2d_0" -> "100 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1"; +"100 UNet/ModuleList[up_path]/UNetUpBlock[0]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" -> "102 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0"; +"101 UNet/ModuleList[up_path]/UNetUpBlock[0]/__getitem___0" -> "102 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0"; +"102 UNet/ModuleList[up_path]/UNetUpBlock[0]/cat_0" -> "106 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"103 up_path.0.conv_block.block.0.weight" -> "105 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"104 up_path.0.conv_block.block.0.bias" -> "106 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"105 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "106 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"106 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" -> "109 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"107 up_path.0.conv_block.block.1.weight" -> "109 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"108 up_path.0.conv_block.block.1.bias" -> "109 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"109 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "110 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; +"110 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "111 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"111 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "115 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"112 up_path.0.conv_block.block.3.weight" -> "114 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"113 up_path.0.conv_block.block.3.bias" -> "115 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"114 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "115 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"115 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" -> "118 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"116 up_path.0.conv_block.block.4.weight" -> "118 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"117 up_path.0.conv_block.block.4.bias" -> "118 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"118 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "119 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; +"119 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "120 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"120 UNet/ModuleList[up_path]/UNetUpBlock[0]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "124 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/conv_transpose2d_0"; +"121 up_path.1.up.weight" -> "123 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; +"122 up_path.1.up.bias" -> "124 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/conv_transpose2d_0"; +"123 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "124 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/conv_transpose2d_0"; +"124 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/conv_transpose2d_0" -> "125 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1"; +"125 UNet/ModuleList[up_path]/UNetUpBlock[1]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" -> "127 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0"; +"126 UNet/ModuleList[up_path]/UNetUpBlock[1]/__getitem___0" -> "127 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0"; +"127 UNet/ModuleList[up_path]/UNetUpBlock[1]/cat_0" -> "131 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"128 up_path.1.conv_block.block.0.weight" -> "130 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"129 up_path.1.conv_block.block.0.bias" -> "131 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"130 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "131 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"131 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" -> "134 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"132 up_path.1.conv_block.block.1.weight" -> "134 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"133 up_path.1.conv_block.block.1.bias" -> "134 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"134 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "135 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; +"135 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "136 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"136 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "140 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"137 up_path.1.conv_block.block.3.weight" -> "139 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"138 up_path.1.conv_block.block.3.bias" -> "140 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"139 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "140 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"140 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" -> "143 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"141 up_path.1.conv_block.block.4.weight" -> "143 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"142 up_path.1.conv_block.block.4.bias" -> "143 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"143 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "144 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; +"144 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "145 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"145 UNet/ModuleList[up_path]/UNetUpBlock[1]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "149 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/conv_transpose2d_0"; +"146 up_path.2.up.weight" -> "148 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; +"147 up_path.2.up.bias" -> "149 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/conv_transpose2d_0"; +"148 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "149 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/conv_transpose2d_0"; +"149 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/conv_transpose2d_0" -> "150 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1"; +"150 UNet/ModuleList[up_path]/UNetUpBlock[2]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" -> "152 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0"; +"151 UNet/ModuleList[up_path]/UNetUpBlock[2]/__getitem___0" -> "152 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0"; +"152 UNet/ModuleList[up_path]/UNetUpBlock[2]/cat_0" -> "156 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"153 up_path.2.conv_block.block.0.weight" -> "155 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"154 up_path.2.conv_block.block.0.bias" -> "156 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"155 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "156 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"156 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" -> "159 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"157 up_path.2.conv_block.block.1.weight" -> "159 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"158 up_path.2.conv_block.block.1.bias" -> "159 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"159 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "160 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; +"160 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "161 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"161 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "165 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"162 up_path.2.conv_block.block.3.weight" -> "164 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"163 up_path.2.conv_block.block.3.bias" -> "165 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"164 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "165 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"165 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" -> "168 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"166 up_path.2.conv_block.block.4.weight" -> "168 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"167 up_path.2.conv_block.block.4.bias" -> "168 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"168 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "169 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; +"169 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "170 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"170 UNet/ModuleList[up_path]/UNetUpBlock[2]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "174 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/conv_transpose2d_0"; +"171 up_path.3.up.weight" -> "173 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0"; +"172 up_path.3.up.bias" -> "174 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/conv_transpose2d_0"; +"173 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_0" -> "174 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/conv_transpose2d_0"; +"174 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/conv_transpose2d_0" -> "175 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1"; +"175 UNet/ModuleList[up_path]/UNetUpBlock[3]/ConvTranspose2d[up]/SymmetricQuantizer/symmetric_quantize_1" -> "177 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0"; +"176 UNet/ModuleList[up_path]/UNetUpBlock[3]/__getitem___0" -> "177 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0"; +"177 UNet/ModuleList[up_path]/UNetUpBlock[3]/cat_0" -> "181 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"178 up_path.3.conv_block.block.0.weight" -> "180 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"179 up_path.3.conv_block.block.0.bias" -> "181 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"180 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "181 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0"; +"181 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[0]/conv2d_0" -> "184 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"182 up_path.3.conv_block.block.1.weight" -> "184 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"183 up_path.3.conv_block.block.1.bias" -> "184 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0"; +"184 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[1]/batch_norm_0" -> "185 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0"; +"185 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/relu_0" -> "186 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"186 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "190 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"187 up_path.3.conv_block.block.3.weight" -> "189 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"188 up_path.3.conv_block.block.3.bias" -> "190 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"189 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "190 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0"; +"190 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/Conv2d[3]/conv2d_0" -> "193 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"191 up_path.3.conv_block.block.4.weight" -> "193 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"192 up_path.3.conv_block.block.4.bias" -> "193 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0"; +"193 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/BatchNorm2d[4]/batch_norm_0" -> "194 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0"; +"194 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/relu_0" -> "195 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"195 UNet/ModuleList[up_path]/UNetUpBlock[3]/UNetConvBlock[conv_block]/Sequential[block]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "199 UNet/Conv2d[last]/conv2d_0"; +"196 last.weight" -> "198 UNet/Conv2d[last]/SymmetricQuantizer/symmetric_quantize_0"; +"197 last.bias" -> "199 UNet/Conv2d[last]/conv2d_0"; +"198 UNet/Conv2d[last]/SymmetricQuantizer/symmetric_quantize_0" -> "199 UNet/Conv2d[last]/conv2d_0"; +"199 UNet/Conv2d[last]/conv2d_0" -> "200 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/vgg16.dot b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/vgg16.dot index ff4210201eb..296720a12aa 100644 --- a/tests/torch/data/reference_graphs/quantized/ptq/symmetric/vgg16.dot +++ b/tests/torch/data/reference_graphs/quantized/ptq/symmetric/vgg16.dot @@ -1,157 +1,265 @@ strict digraph { "0 /nncf_model_input_0" [id=0, type=nncf_model_input]; "1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; -"2 VGG/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; -"3 VGG/Sequential[features]/NNCFConv2d[0]/conv2d_0" [id=3, type=conv2d]; -"4 VGG/Sequential[features]/NNCFBatchNorm2d[1]/batch_norm_0" [id=4, type=batch_norm]; -"5 VGG/Sequential[features]/ReLU[2]/relu__0" [id=5, type=relu_]; -"6 VGG/Sequential[features]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; -"7 VGG/Sequential[features]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=7, type=symmetric_quantize]; -"8 VGG/Sequential[features]/NNCFConv2d[3]/conv2d_0" [id=8, type=conv2d]; -"9 VGG/Sequential[features]/NNCFBatchNorm2d[4]/batch_norm_0" [id=9, type=batch_norm]; -"10 VGG/Sequential[features]/ReLU[5]/relu__0" [id=10, type=relu_]; -"11 VGG/Sequential[features]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=11, type=symmetric_quantize]; -"12 VGG/Sequential[features]/MaxPool2d[6]/max_pool2d_0" [id=12, type=max_pool2d]; -"13 VGG/Sequential[features]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; -"14 VGG/Sequential[features]/NNCFConv2d[7]/conv2d_0" [id=14, type=conv2d]; -"15 VGG/Sequential[features]/NNCFBatchNorm2d[8]/batch_norm_0" [id=15, type=batch_norm]; -"16 VGG/Sequential[features]/ReLU[9]/relu__0" [id=16, type=relu_]; -"17 VGG/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" [id=17, type=symmetric_quantize]; -"18 VGG/Sequential[features]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=18, type=symmetric_quantize]; -"19 VGG/Sequential[features]/NNCFConv2d[10]/conv2d_0" [id=19, type=conv2d]; -"20 VGG/Sequential[features]/NNCFBatchNorm2d[11]/batch_norm_0" [id=20, type=batch_norm]; -"21 VGG/Sequential[features]/ReLU[12]/relu__0" [id=21, type=relu_]; -"22 VGG/Sequential[features]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" [id=22, type=symmetric_quantize]; -"23 VGG/Sequential[features]/MaxPool2d[13]/max_pool2d_0" [id=23, type=max_pool2d]; -"24 VGG/Sequential[features]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=24, type=symmetric_quantize]; -"25 VGG/Sequential[features]/NNCFConv2d[14]/conv2d_0" [id=25, type=conv2d]; -"26 VGG/Sequential[features]/NNCFBatchNorm2d[15]/batch_norm_0" [id=26, type=batch_norm]; -"27 VGG/Sequential[features]/ReLU[16]/relu__0" [id=27, type=relu_]; -"28 VGG/Sequential[features]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" [id=28, type=symmetric_quantize]; -"29 VGG/Sequential[features]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=29, type=symmetric_quantize]; -"30 VGG/Sequential[features]/NNCFConv2d[17]/conv2d_0" [id=30, type=conv2d]; -"31 VGG/Sequential[features]/NNCFBatchNorm2d[18]/batch_norm_0" [id=31, type=batch_norm]; -"32 VGG/Sequential[features]/ReLU[19]/relu__0" [id=32, type=relu_]; -"33 VGG/Sequential[features]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; -"34 VGG/Sequential[features]/NNCFConv2d[20]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=34, type=symmetric_quantize]; -"35 VGG/Sequential[features]/NNCFConv2d[20]/conv2d_0" [id=35, type=conv2d]; -"36 VGG/Sequential[features]/NNCFBatchNorm2d[21]/batch_norm_0" [id=36, type=batch_norm]; -"37 VGG/Sequential[features]/ReLU[22]/relu__0" [id=37, type=relu_]; -"38 VGG/Sequential[features]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; -"39 VGG/Sequential[features]/MaxPool2d[23]/max_pool2d_0" [id=39, type=max_pool2d]; -"40 VGG/Sequential[features]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=40, type=symmetric_quantize]; -"41 VGG/Sequential[features]/NNCFConv2d[24]/conv2d_0" [id=41, type=conv2d]; -"42 VGG/Sequential[features]/NNCFBatchNorm2d[25]/batch_norm_0" [id=42, type=batch_norm]; -"43 VGG/Sequential[features]/ReLU[26]/relu__0" [id=43, type=relu_]; -"44 VGG/Sequential[features]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" [id=44, type=symmetric_quantize]; -"45 VGG/Sequential[features]/NNCFConv2d[27]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=45, type=symmetric_quantize]; -"46 VGG/Sequential[features]/NNCFConv2d[27]/conv2d_0" [id=46, type=conv2d]; -"47 VGG/Sequential[features]/NNCFBatchNorm2d[28]/batch_norm_0" [id=47, type=batch_norm]; -"48 VGG/Sequential[features]/ReLU[29]/relu__0" [id=48, type=relu_]; -"49 VGG/Sequential[features]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" [id=49, type=symmetric_quantize]; -"50 VGG/Sequential[features]/NNCFConv2d[30]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=50, type=symmetric_quantize]; -"51 VGG/Sequential[features]/NNCFConv2d[30]/conv2d_0" [id=51, type=conv2d]; -"52 VGG/Sequential[features]/NNCFBatchNorm2d[31]/batch_norm_0" [id=52, type=batch_norm]; -"53 VGG/Sequential[features]/ReLU[32]/relu__0" [id=53, type=relu_]; -"54 VGG/Sequential[features]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" [id=54, type=symmetric_quantize]; -"55 VGG/Sequential[features]/MaxPool2d[33]/max_pool2d_0" [id=55, type=max_pool2d]; -"56 VGG/Sequential[features]/NNCFConv2d[34]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; -"57 VGG/Sequential[features]/NNCFConv2d[34]/conv2d_0" [id=57, type=conv2d]; -"58 VGG/Sequential[features]/NNCFBatchNorm2d[35]/batch_norm_0" [id=58, type=batch_norm]; -"59 VGG/Sequential[features]/ReLU[36]/relu__0" [id=59, type=relu_]; -"60 VGG/Sequential[features]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; -"61 VGG/Sequential[features]/NNCFConv2d[37]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=61, type=symmetric_quantize]; -"62 VGG/Sequential[features]/NNCFConv2d[37]/conv2d_0" [id=62, type=conv2d]; -"63 VGG/Sequential[features]/NNCFBatchNorm2d[38]/batch_norm_0" [id=63, type=batch_norm]; -"64 VGG/Sequential[features]/ReLU[39]/relu__0" [id=64, type=relu_]; -"65 VGG/Sequential[features]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" [id=65, type=symmetric_quantize]; -"66 VGG/Sequential[features]/NNCFConv2d[40]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=66, type=symmetric_quantize]; -"67 VGG/Sequential[features]/NNCFConv2d[40]/conv2d_0" [id=67, type=conv2d]; -"68 VGG/Sequential[features]/NNCFBatchNorm2d[41]/batch_norm_0" [id=68, type=batch_norm]; -"69 VGG/Sequential[features]/ReLU[42]/relu__0" [id=69, type=relu_]; -"70 VGG/Sequential[features]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; -"71 VGG/Sequential[features]/MaxPool2d[43]/max_pool2d_0" [id=71, type=max_pool2d]; -"72 VGG/Sequential[features]/AvgPool2d[44]/avg_pool2d_0" [id=72, type=avg_pool2d]; -"73 VGG/Sequential[features]/AvgPool2d[44]/SymmetricQuantizer/symmetric_quantize_0" [id=73, type=symmetric_quantize]; -"74 VGG/view_0" [id=74, type=view]; -"75 VGG/NNCFLinear[classifier]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=75, type=symmetric_quantize]; -"76 VGG/NNCFLinear[classifier]/linear_0" [id=76, type=linear]; -"77 /nncf_model_output_0" [id=77, type=nncf_model_output]; +"2 features.0.weight" [id=2, type=nncf_model_const]; +"3 features.0.bias" [id=3, type=nncf_model_const]; +"4 VGG/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" [id=4, type=symmetric_quantize]; +"5 VGG/Sequential[features]/Conv2d[0]/conv2d_0" [id=5, type=conv2d]; +"6 features.1.weight" [id=6, type=nncf_model_const]; +"7 features.1.bias" [id=7, type=nncf_model_const]; +"8 VGG/Sequential[features]/BatchNorm2d[1]/batch_norm_0" [id=8, type=batch_norm]; +"9 VGG/Sequential[features]/ReLU[2]/relu__0" [id=9, type=relu_]; +"10 VGG/Sequential[features]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" [id=10, type=symmetric_quantize]; +"11 features.3.weight" [id=11, type=nncf_model_const]; +"12 features.3.bias" [id=12, type=nncf_model_const]; +"13 VGG/Sequential[features]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 VGG/Sequential[features]/Conv2d[3]/conv2d_0" [id=14, type=conv2d]; +"15 features.4.weight" [id=15, type=nncf_model_const]; +"16 features.4.bias" [id=16, type=nncf_model_const]; +"17 VGG/Sequential[features]/BatchNorm2d[4]/batch_norm_0" [id=17, type=batch_norm]; +"18 VGG/Sequential[features]/ReLU[5]/relu__0" [id=18, type=relu_]; +"19 VGG/Sequential[features]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; +"20 VGG/Sequential[features]/MaxPool2d[6]/max_pool2d_0" [id=20, type=max_pool2d]; +"21 features.7.weight" [id=21, type=nncf_model_const]; +"22 features.7.bias" [id=22, type=nncf_model_const]; +"23 VGG/Sequential[features]/Conv2d[7]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; +"24 VGG/Sequential[features]/Conv2d[7]/conv2d_0" [id=24, type=conv2d]; +"25 features.8.weight" [id=25, type=nncf_model_const]; +"26 features.8.bias" [id=26, type=nncf_model_const]; +"27 VGG/Sequential[features]/BatchNorm2d[8]/batch_norm_0" [id=27, type=batch_norm]; +"28 VGG/Sequential[features]/ReLU[9]/relu__0" [id=28, type=relu_]; +"29 VGG/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" [id=29, type=symmetric_quantize]; +"30 features.10.weight" [id=30, type=nncf_model_const]; +"31 features.10.bias" [id=31, type=nncf_model_const]; +"32 VGG/Sequential[features]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0" [id=32, type=symmetric_quantize]; +"33 VGG/Sequential[features]/Conv2d[10]/conv2d_0" [id=33, type=conv2d]; +"34 features.11.weight" [id=34, type=nncf_model_const]; +"35 features.11.bias" [id=35, type=nncf_model_const]; +"36 VGG/Sequential[features]/BatchNorm2d[11]/batch_norm_0" [id=36, type=batch_norm]; +"37 VGG/Sequential[features]/ReLU[12]/relu__0" [id=37, type=relu_]; +"38 VGG/Sequential[features]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 VGG/Sequential[features]/MaxPool2d[13]/max_pool2d_0" [id=39, type=max_pool2d]; +"40 features.14.weight" [id=40, type=nncf_model_const]; +"41 features.14.bias" [id=41, type=nncf_model_const]; +"42 VGG/Sequential[features]/Conv2d[14]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 VGG/Sequential[features]/Conv2d[14]/conv2d_0" [id=43, type=conv2d]; +"44 features.15.weight" [id=44, type=nncf_model_const]; +"45 features.15.bias" [id=45, type=nncf_model_const]; +"46 VGG/Sequential[features]/BatchNorm2d[15]/batch_norm_0" [id=46, type=batch_norm]; +"47 VGG/Sequential[features]/ReLU[16]/relu__0" [id=47, type=relu_]; +"48 VGG/Sequential[features]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 features.17.weight" [id=49, type=nncf_model_const]; +"50 features.17.bias" [id=50, type=nncf_model_const]; +"51 VGG/Sequential[features]/Conv2d[17]/SymmetricQuantizer/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 VGG/Sequential[features]/Conv2d[17]/conv2d_0" [id=52, type=conv2d]; +"53 features.18.weight" [id=53, type=nncf_model_const]; +"54 features.18.bias" [id=54, type=nncf_model_const]; +"55 VGG/Sequential[features]/BatchNorm2d[18]/batch_norm_0" [id=55, type=batch_norm]; +"56 VGG/Sequential[features]/ReLU[19]/relu__0" [id=56, type=relu_]; +"57 VGG/Sequential[features]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" [id=57, type=symmetric_quantize]; +"58 features.20.weight" [id=58, type=nncf_model_const]; +"59 features.20.bias" [id=59, type=nncf_model_const]; +"60 VGG/Sequential[features]/Conv2d[20]/SymmetricQuantizer/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 VGG/Sequential[features]/Conv2d[20]/conv2d_0" [id=61, type=conv2d]; +"62 features.21.weight" [id=62, type=nncf_model_const]; +"63 features.21.bias" [id=63, type=nncf_model_const]; +"64 VGG/Sequential[features]/BatchNorm2d[21]/batch_norm_0" [id=64, type=batch_norm]; +"65 VGG/Sequential[features]/ReLU[22]/relu__0" [id=65, type=relu_]; +"66 VGG/Sequential[features]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" [id=66, type=symmetric_quantize]; +"67 VGG/Sequential[features]/MaxPool2d[23]/max_pool2d_0" [id=67, type=max_pool2d]; +"68 features.24.weight" [id=68, type=nncf_model_const]; +"69 features.24.bias" [id=69, type=nncf_model_const]; +"70 VGG/Sequential[features]/Conv2d[24]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 VGG/Sequential[features]/Conv2d[24]/conv2d_0" [id=71, type=conv2d]; +"72 features.25.weight" [id=72, type=nncf_model_const]; +"73 features.25.bias" [id=73, type=nncf_model_const]; +"74 VGG/Sequential[features]/BatchNorm2d[25]/batch_norm_0" [id=74, type=batch_norm]; +"75 VGG/Sequential[features]/ReLU[26]/relu__0" [id=75, type=relu_]; +"76 VGG/Sequential[features]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; +"77 features.27.weight" [id=77, type=nncf_model_const]; +"78 features.27.bias" [id=78, type=nncf_model_const]; +"79 VGG/Sequential[features]/Conv2d[27]/SymmetricQuantizer/symmetric_quantize_0" [id=79, type=symmetric_quantize]; +"80 VGG/Sequential[features]/Conv2d[27]/conv2d_0" [id=80, type=conv2d]; +"81 features.28.weight" [id=81, type=nncf_model_const]; +"82 features.28.bias" [id=82, type=nncf_model_const]; +"83 VGG/Sequential[features]/BatchNorm2d[28]/batch_norm_0" [id=83, type=batch_norm]; +"84 VGG/Sequential[features]/ReLU[29]/relu__0" [id=84, type=relu_]; +"85 VGG/Sequential[features]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; +"86 features.30.weight" [id=86, type=nncf_model_const]; +"87 features.30.bias" [id=87, type=nncf_model_const]; +"88 VGG/Sequential[features]/Conv2d[30]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; +"89 VGG/Sequential[features]/Conv2d[30]/conv2d_0" [id=89, type=conv2d]; +"90 features.31.weight" [id=90, type=nncf_model_const]; +"91 features.31.bias" [id=91, type=nncf_model_const]; +"92 VGG/Sequential[features]/BatchNorm2d[31]/batch_norm_0" [id=92, type=batch_norm]; +"93 VGG/Sequential[features]/ReLU[32]/relu__0" [id=93, type=relu_]; +"94 VGG/Sequential[features]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 VGG/Sequential[features]/MaxPool2d[33]/max_pool2d_0" [id=95, type=max_pool2d]; +"96 features.34.weight" [id=96, type=nncf_model_const]; +"97 features.34.bias" [id=97, type=nncf_model_const]; +"98 VGG/Sequential[features]/Conv2d[34]/SymmetricQuantizer/symmetric_quantize_0" [id=98, type=symmetric_quantize]; +"99 VGG/Sequential[features]/Conv2d[34]/conv2d_0" [id=99, type=conv2d]; +"100 features.35.weight" [id=100, type=nncf_model_const]; +"101 features.35.bias" [id=101, type=nncf_model_const]; +"102 VGG/Sequential[features]/BatchNorm2d[35]/batch_norm_0" [id=102, type=batch_norm]; +"103 VGG/Sequential[features]/ReLU[36]/relu__0" [id=103, type=relu_]; +"104 VGG/Sequential[features]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" [id=104, type=symmetric_quantize]; +"105 features.37.weight" [id=105, type=nncf_model_const]; +"106 features.37.bias" [id=106, type=nncf_model_const]; +"107 VGG/Sequential[features]/Conv2d[37]/SymmetricQuantizer/symmetric_quantize_0" [id=107, type=symmetric_quantize]; +"108 VGG/Sequential[features]/Conv2d[37]/conv2d_0" [id=108, type=conv2d]; +"109 features.38.weight" [id=109, type=nncf_model_const]; +"110 features.38.bias" [id=110, type=nncf_model_const]; +"111 VGG/Sequential[features]/BatchNorm2d[38]/batch_norm_0" [id=111, type=batch_norm]; +"112 VGG/Sequential[features]/ReLU[39]/relu__0" [id=112, type=relu_]; +"113 VGG/Sequential[features]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" [id=113, type=symmetric_quantize]; +"114 features.40.weight" [id=114, type=nncf_model_const]; +"115 features.40.bias" [id=115, type=nncf_model_const]; +"116 VGG/Sequential[features]/Conv2d[40]/SymmetricQuantizer/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 VGG/Sequential[features]/Conv2d[40]/conv2d_0" [id=117, type=conv2d]; +"118 features.41.weight" [id=118, type=nncf_model_const]; +"119 features.41.bias" [id=119, type=nncf_model_const]; +"120 VGG/Sequential[features]/BatchNorm2d[41]/batch_norm_0" [id=120, type=batch_norm]; +"121 VGG/Sequential[features]/ReLU[42]/relu__0" [id=121, type=relu_]; +"122 VGG/Sequential[features]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; +"123 VGG/Sequential[features]/MaxPool2d[43]/max_pool2d_0" [id=123, type=max_pool2d]; +"124 VGG/Sequential[features]/AvgPool2d[44]/avg_pool2d_0" [id=124, type=avg_pool2d]; +"125 VGG/Sequential[features]/AvgPool2d[44]/SymmetricQuantizer/symmetric_quantize_0" [id=125, type=symmetric_quantize]; +"126 VGG/view_0" [id=126, type=view]; +"127 classifier.weight" [id=127, type=nncf_model_const]; +"128 classifier.bias" [id=128, type=nncf_model_const]; +"129 VGG/Linear[classifier]/SymmetricQuantizer/symmetric_quantize_0" [id=129, type=symmetric_quantize]; +"130 VGG/Linear[classifier]/linear_0" [id=130, type=linear]; +"131 /nncf_model_output_0" [id=131, type=nncf_model_output]; "0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; -"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 VGG/Sequential[features]/NNCFConv2d[0]/conv2d_0"; -"2 VGG/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 VGG/Sequential[features]/NNCFConv2d[0]/conv2d_0"; -"3 VGG/Sequential[features]/NNCFConv2d[0]/conv2d_0" -> "4 VGG/Sequential[features]/NNCFBatchNorm2d[1]/batch_norm_0"; -"4 VGG/Sequential[features]/NNCFBatchNorm2d[1]/batch_norm_0" -> "5 VGG/Sequential[features]/ReLU[2]/relu__0"; -"5 VGG/Sequential[features]/ReLU[2]/relu__0" -> "6 VGG/Sequential[features]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; -"6 VGG/Sequential[features]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "8 VGG/Sequential[features]/NNCFConv2d[3]/conv2d_0"; -"7 VGG/Sequential[features]/NNCFConv2d[3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "8 VGG/Sequential[features]/NNCFConv2d[3]/conv2d_0"; -"8 VGG/Sequential[features]/NNCFConv2d[3]/conv2d_0" -> "9 VGG/Sequential[features]/NNCFBatchNorm2d[4]/batch_norm_0"; -"9 VGG/Sequential[features]/NNCFBatchNorm2d[4]/batch_norm_0" -> "10 VGG/Sequential[features]/ReLU[5]/relu__0"; -"10 VGG/Sequential[features]/ReLU[5]/relu__0" -> "11 VGG/Sequential[features]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; -"11 VGG/Sequential[features]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "12 VGG/Sequential[features]/MaxPool2d[6]/max_pool2d_0"; -"12 VGG/Sequential[features]/MaxPool2d[6]/max_pool2d_0" -> "14 VGG/Sequential[features]/NNCFConv2d[7]/conv2d_0"; -"13 VGG/Sequential[features]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 VGG/Sequential[features]/NNCFConv2d[7]/conv2d_0"; -"14 VGG/Sequential[features]/NNCFConv2d[7]/conv2d_0" -> "15 VGG/Sequential[features]/NNCFBatchNorm2d[8]/batch_norm_0"; -"15 VGG/Sequential[features]/NNCFBatchNorm2d[8]/batch_norm_0" -> "16 VGG/Sequential[features]/ReLU[9]/relu__0"; -"16 VGG/Sequential[features]/ReLU[9]/relu__0" -> "17 VGG/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0"; -"17 VGG/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" -> "19 VGG/Sequential[features]/NNCFConv2d[10]/conv2d_0"; -"18 VGG/Sequential[features]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "19 VGG/Sequential[features]/NNCFConv2d[10]/conv2d_0"; -"19 VGG/Sequential[features]/NNCFConv2d[10]/conv2d_0" -> "20 VGG/Sequential[features]/NNCFBatchNorm2d[11]/batch_norm_0"; -"20 VGG/Sequential[features]/NNCFBatchNorm2d[11]/batch_norm_0" -> "21 VGG/Sequential[features]/ReLU[12]/relu__0"; -"21 VGG/Sequential[features]/ReLU[12]/relu__0" -> "22 VGG/Sequential[features]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0"; -"22 VGG/Sequential[features]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" -> "23 VGG/Sequential[features]/MaxPool2d[13]/max_pool2d_0"; -"23 VGG/Sequential[features]/MaxPool2d[13]/max_pool2d_0" -> "25 VGG/Sequential[features]/NNCFConv2d[14]/conv2d_0"; -"24 VGG/Sequential[features]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "25 VGG/Sequential[features]/NNCFConv2d[14]/conv2d_0"; -"25 VGG/Sequential[features]/NNCFConv2d[14]/conv2d_0" -> "26 VGG/Sequential[features]/NNCFBatchNorm2d[15]/batch_norm_0"; -"26 VGG/Sequential[features]/NNCFBatchNorm2d[15]/batch_norm_0" -> "27 VGG/Sequential[features]/ReLU[16]/relu__0"; -"27 VGG/Sequential[features]/ReLU[16]/relu__0" -> "28 VGG/Sequential[features]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0"; -"28 VGG/Sequential[features]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" -> "30 VGG/Sequential[features]/NNCFConv2d[17]/conv2d_0"; -"29 VGG/Sequential[features]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "30 VGG/Sequential[features]/NNCFConv2d[17]/conv2d_0"; -"30 VGG/Sequential[features]/NNCFConv2d[17]/conv2d_0" -> "31 VGG/Sequential[features]/NNCFBatchNorm2d[18]/batch_norm_0"; -"31 VGG/Sequential[features]/NNCFBatchNorm2d[18]/batch_norm_0" -> "32 VGG/Sequential[features]/ReLU[19]/relu__0"; -"32 VGG/Sequential[features]/ReLU[19]/relu__0" -> "33 VGG/Sequential[features]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0"; -"33 VGG/Sequential[features]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" -> "35 VGG/Sequential[features]/NNCFConv2d[20]/conv2d_0"; -"34 VGG/Sequential[features]/NNCFConv2d[20]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "35 VGG/Sequential[features]/NNCFConv2d[20]/conv2d_0"; -"35 VGG/Sequential[features]/NNCFConv2d[20]/conv2d_0" -> "36 VGG/Sequential[features]/NNCFBatchNorm2d[21]/batch_norm_0"; -"36 VGG/Sequential[features]/NNCFBatchNorm2d[21]/batch_norm_0" -> "37 VGG/Sequential[features]/ReLU[22]/relu__0"; -"37 VGG/Sequential[features]/ReLU[22]/relu__0" -> "38 VGG/Sequential[features]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0"; -"38 VGG/Sequential[features]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" -> "39 VGG/Sequential[features]/MaxPool2d[23]/max_pool2d_0"; -"39 VGG/Sequential[features]/MaxPool2d[23]/max_pool2d_0" -> "41 VGG/Sequential[features]/NNCFConv2d[24]/conv2d_0"; -"40 VGG/Sequential[features]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "41 VGG/Sequential[features]/NNCFConv2d[24]/conv2d_0"; -"41 VGG/Sequential[features]/NNCFConv2d[24]/conv2d_0" -> "42 VGG/Sequential[features]/NNCFBatchNorm2d[25]/batch_norm_0"; -"42 VGG/Sequential[features]/NNCFBatchNorm2d[25]/batch_norm_0" -> "43 VGG/Sequential[features]/ReLU[26]/relu__0"; -"43 VGG/Sequential[features]/ReLU[26]/relu__0" -> "44 VGG/Sequential[features]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0"; -"44 VGG/Sequential[features]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" -> "46 VGG/Sequential[features]/NNCFConv2d[27]/conv2d_0"; -"45 VGG/Sequential[features]/NNCFConv2d[27]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "46 VGG/Sequential[features]/NNCFConv2d[27]/conv2d_0"; -"46 VGG/Sequential[features]/NNCFConv2d[27]/conv2d_0" -> "47 VGG/Sequential[features]/NNCFBatchNorm2d[28]/batch_norm_0"; -"47 VGG/Sequential[features]/NNCFBatchNorm2d[28]/batch_norm_0" -> "48 VGG/Sequential[features]/ReLU[29]/relu__0"; -"48 VGG/Sequential[features]/ReLU[29]/relu__0" -> "49 VGG/Sequential[features]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0"; -"49 VGG/Sequential[features]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" -> "51 VGG/Sequential[features]/NNCFConv2d[30]/conv2d_0"; -"50 VGG/Sequential[features]/NNCFConv2d[30]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "51 VGG/Sequential[features]/NNCFConv2d[30]/conv2d_0"; -"51 VGG/Sequential[features]/NNCFConv2d[30]/conv2d_0" -> "52 VGG/Sequential[features]/NNCFBatchNorm2d[31]/batch_norm_0"; -"52 VGG/Sequential[features]/NNCFBatchNorm2d[31]/batch_norm_0" -> "53 VGG/Sequential[features]/ReLU[32]/relu__0"; -"53 VGG/Sequential[features]/ReLU[32]/relu__0" -> "54 VGG/Sequential[features]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0"; -"54 VGG/Sequential[features]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "55 VGG/Sequential[features]/MaxPool2d[33]/max_pool2d_0"; -"55 VGG/Sequential[features]/MaxPool2d[33]/max_pool2d_0" -> "57 VGG/Sequential[features]/NNCFConv2d[34]/conv2d_0"; -"56 VGG/Sequential[features]/NNCFConv2d[34]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 VGG/Sequential[features]/NNCFConv2d[34]/conv2d_0"; -"57 VGG/Sequential[features]/NNCFConv2d[34]/conv2d_0" -> "58 VGG/Sequential[features]/NNCFBatchNorm2d[35]/batch_norm_0"; -"58 VGG/Sequential[features]/NNCFBatchNorm2d[35]/batch_norm_0" -> "59 VGG/Sequential[features]/ReLU[36]/relu__0"; -"59 VGG/Sequential[features]/ReLU[36]/relu__0" -> "60 VGG/Sequential[features]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0"; -"60 VGG/Sequential[features]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" -> "62 VGG/Sequential[features]/NNCFConv2d[37]/conv2d_0"; -"61 VGG/Sequential[features]/NNCFConv2d[37]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "62 VGG/Sequential[features]/NNCFConv2d[37]/conv2d_0"; -"62 VGG/Sequential[features]/NNCFConv2d[37]/conv2d_0" -> "63 VGG/Sequential[features]/NNCFBatchNorm2d[38]/batch_norm_0"; -"63 VGG/Sequential[features]/NNCFBatchNorm2d[38]/batch_norm_0" -> "64 VGG/Sequential[features]/ReLU[39]/relu__0"; -"64 VGG/Sequential[features]/ReLU[39]/relu__0" -> "65 VGG/Sequential[features]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0"; -"65 VGG/Sequential[features]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" -> "67 VGG/Sequential[features]/NNCFConv2d[40]/conv2d_0"; -"66 VGG/Sequential[features]/NNCFConv2d[40]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "67 VGG/Sequential[features]/NNCFConv2d[40]/conv2d_0"; -"67 VGG/Sequential[features]/NNCFConv2d[40]/conv2d_0" -> "68 VGG/Sequential[features]/NNCFBatchNorm2d[41]/batch_norm_0"; -"68 VGG/Sequential[features]/NNCFBatchNorm2d[41]/batch_norm_0" -> "69 VGG/Sequential[features]/ReLU[42]/relu__0"; -"69 VGG/Sequential[features]/ReLU[42]/relu__0" -> "70 VGG/Sequential[features]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0"; -"70 VGG/Sequential[features]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" -> "71 VGG/Sequential[features]/MaxPool2d[43]/max_pool2d_0"; -"71 VGG/Sequential[features]/MaxPool2d[43]/max_pool2d_0" -> "72 VGG/Sequential[features]/AvgPool2d[44]/avg_pool2d_0"; -"72 VGG/Sequential[features]/AvgPool2d[44]/avg_pool2d_0" -> "73 VGG/Sequential[features]/AvgPool2d[44]/SymmetricQuantizer/symmetric_quantize_0"; -"73 VGG/Sequential[features]/AvgPool2d[44]/SymmetricQuantizer/symmetric_quantize_0" -> "74 VGG/view_0"; -"74 VGG/view_0" -> "76 VGG/NNCFLinear[classifier]/linear_0"; -"75 VGG/NNCFLinear[classifier]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "76 VGG/NNCFLinear[classifier]/linear_0"; -"76 VGG/NNCFLinear[classifier]/linear_0" -> "77 /nncf_model_output_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "5 VGG/Sequential[features]/Conv2d[0]/conv2d_0"; +"2 features.0.weight" -> "4 VGG/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0"; +"3 features.0.bias" -> "5 VGG/Sequential[features]/Conv2d[0]/conv2d_0"; +"4 VGG/Sequential[features]/Conv2d[0]/SymmetricQuantizer/symmetric_quantize_0" -> "5 VGG/Sequential[features]/Conv2d[0]/conv2d_0"; +"5 VGG/Sequential[features]/Conv2d[0]/conv2d_0" -> "8 VGG/Sequential[features]/BatchNorm2d[1]/batch_norm_0"; +"6 features.1.weight" -> "8 VGG/Sequential[features]/BatchNorm2d[1]/batch_norm_0"; +"7 features.1.bias" -> "8 VGG/Sequential[features]/BatchNorm2d[1]/batch_norm_0"; +"8 VGG/Sequential[features]/BatchNorm2d[1]/batch_norm_0" -> "9 VGG/Sequential[features]/ReLU[2]/relu__0"; +"9 VGG/Sequential[features]/ReLU[2]/relu__0" -> "10 VGG/Sequential[features]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0"; +"10 VGG/Sequential[features]/ReLU[2]/SymmetricQuantizer/symmetric_quantize_0" -> "14 VGG/Sequential[features]/Conv2d[3]/conv2d_0"; +"11 features.3.weight" -> "13 VGG/Sequential[features]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0"; +"12 features.3.bias" -> "14 VGG/Sequential[features]/Conv2d[3]/conv2d_0"; +"13 VGG/Sequential[features]/Conv2d[3]/SymmetricQuantizer/symmetric_quantize_0" -> "14 VGG/Sequential[features]/Conv2d[3]/conv2d_0"; +"14 VGG/Sequential[features]/Conv2d[3]/conv2d_0" -> "17 VGG/Sequential[features]/BatchNorm2d[4]/batch_norm_0"; +"15 features.4.weight" -> "17 VGG/Sequential[features]/BatchNorm2d[4]/batch_norm_0"; +"16 features.4.bias" -> "17 VGG/Sequential[features]/BatchNorm2d[4]/batch_norm_0"; +"17 VGG/Sequential[features]/BatchNorm2d[4]/batch_norm_0" -> "18 VGG/Sequential[features]/ReLU[5]/relu__0"; +"18 VGG/Sequential[features]/ReLU[5]/relu__0" -> "19 VGG/Sequential[features]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0"; +"19 VGG/Sequential[features]/ReLU[5]/SymmetricQuantizer/symmetric_quantize_0" -> "20 VGG/Sequential[features]/MaxPool2d[6]/max_pool2d_0"; +"20 VGG/Sequential[features]/MaxPool2d[6]/max_pool2d_0" -> "24 VGG/Sequential[features]/Conv2d[7]/conv2d_0"; +"21 features.7.weight" -> "23 VGG/Sequential[features]/Conv2d[7]/SymmetricQuantizer/symmetric_quantize_0"; +"22 features.7.bias" -> "24 VGG/Sequential[features]/Conv2d[7]/conv2d_0"; +"23 VGG/Sequential[features]/Conv2d[7]/SymmetricQuantizer/symmetric_quantize_0" -> "24 VGG/Sequential[features]/Conv2d[7]/conv2d_0"; +"24 VGG/Sequential[features]/Conv2d[7]/conv2d_0" -> "27 VGG/Sequential[features]/BatchNorm2d[8]/batch_norm_0"; +"25 features.8.weight" -> "27 VGG/Sequential[features]/BatchNorm2d[8]/batch_norm_0"; +"26 features.8.bias" -> "27 VGG/Sequential[features]/BatchNorm2d[8]/batch_norm_0"; +"27 VGG/Sequential[features]/BatchNorm2d[8]/batch_norm_0" -> "28 VGG/Sequential[features]/ReLU[9]/relu__0"; +"28 VGG/Sequential[features]/ReLU[9]/relu__0" -> "29 VGG/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0"; +"29 VGG/Sequential[features]/ReLU[9]/SymmetricQuantizer/symmetric_quantize_0" -> "33 VGG/Sequential[features]/Conv2d[10]/conv2d_0"; +"30 features.10.weight" -> "32 VGG/Sequential[features]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0"; +"31 features.10.bias" -> "33 VGG/Sequential[features]/Conv2d[10]/conv2d_0"; +"32 VGG/Sequential[features]/Conv2d[10]/SymmetricQuantizer/symmetric_quantize_0" -> "33 VGG/Sequential[features]/Conv2d[10]/conv2d_0"; +"33 VGG/Sequential[features]/Conv2d[10]/conv2d_0" -> "36 VGG/Sequential[features]/BatchNorm2d[11]/batch_norm_0"; +"34 features.11.weight" -> "36 VGG/Sequential[features]/BatchNorm2d[11]/batch_norm_0"; +"35 features.11.bias" -> "36 VGG/Sequential[features]/BatchNorm2d[11]/batch_norm_0"; +"36 VGG/Sequential[features]/BatchNorm2d[11]/batch_norm_0" -> "37 VGG/Sequential[features]/ReLU[12]/relu__0"; +"37 VGG/Sequential[features]/ReLU[12]/relu__0" -> "38 VGG/Sequential[features]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0"; +"38 VGG/Sequential[features]/ReLU[12]/SymmetricQuantizer/symmetric_quantize_0" -> "39 VGG/Sequential[features]/MaxPool2d[13]/max_pool2d_0"; +"39 VGG/Sequential[features]/MaxPool2d[13]/max_pool2d_0" -> "43 VGG/Sequential[features]/Conv2d[14]/conv2d_0"; +"40 features.14.weight" -> "42 VGG/Sequential[features]/Conv2d[14]/SymmetricQuantizer/symmetric_quantize_0"; +"41 features.14.bias" -> "43 VGG/Sequential[features]/Conv2d[14]/conv2d_0"; +"42 VGG/Sequential[features]/Conv2d[14]/SymmetricQuantizer/symmetric_quantize_0" -> "43 VGG/Sequential[features]/Conv2d[14]/conv2d_0"; +"43 VGG/Sequential[features]/Conv2d[14]/conv2d_0" -> "46 VGG/Sequential[features]/BatchNorm2d[15]/batch_norm_0"; +"44 features.15.weight" -> "46 VGG/Sequential[features]/BatchNorm2d[15]/batch_norm_0"; +"45 features.15.bias" -> "46 VGG/Sequential[features]/BatchNorm2d[15]/batch_norm_0"; +"46 VGG/Sequential[features]/BatchNorm2d[15]/batch_norm_0" -> "47 VGG/Sequential[features]/ReLU[16]/relu__0"; +"47 VGG/Sequential[features]/ReLU[16]/relu__0" -> "48 VGG/Sequential[features]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0"; +"48 VGG/Sequential[features]/ReLU[16]/SymmetricQuantizer/symmetric_quantize_0" -> "52 VGG/Sequential[features]/Conv2d[17]/conv2d_0"; +"49 features.17.weight" -> "51 VGG/Sequential[features]/Conv2d[17]/SymmetricQuantizer/symmetric_quantize_0"; +"50 features.17.bias" -> "52 VGG/Sequential[features]/Conv2d[17]/conv2d_0"; +"51 VGG/Sequential[features]/Conv2d[17]/SymmetricQuantizer/symmetric_quantize_0" -> "52 VGG/Sequential[features]/Conv2d[17]/conv2d_0"; +"52 VGG/Sequential[features]/Conv2d[17]/conv2d_0" -> "55 VGG/Sequential[features]/BatchNorm2d[18]/batch_norm_0"; +"53 features.18.weight" -> "55 VGG/Sequential[features]/BatchNorm2d[18]/batch_norm_0"; +"54 features.18.bias" -> "55 VGG/Sequential[features]/BatchNorm2d[18]/batch_norm_0"; +"55 VGG/Sequential[features]/BatchNorm2d[18]/batch_norm_0" -> "56 VGG/Sequential[features]/ReLU[19]/relu__0"; +"56 VGG/Sequential[features]/ReLU[19]/relu__0" -> "57 VGG/Sequential[features]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0"; +"57 VGG/Sequential[features]/ReLU[19]/SymmetricQuantizer/symmetric_quantize_0" -> "61 VGG/Sequential[features]/Conv2d[20]/conv2d_0"; +"58 features.20.weight" -> "60 VGG/Sequential[features]/Conv2d[20]/SymmetricQuantizer/symmetric_quantize_0"; +"59 features.20.bias" -> "61 VGG/Sequential[features]/Conv2d[20]/conv2d_0"; +"60 VGG/Sequential[features]/Conv2d[20]/SymmetricQuantizer/symmetric_quantize_0" -> "61 VGG/Sequential[features]/Conv2d[20]/conv2d_0"; +"61 VGG/Sequential[features]/Conv2d[20]/conv2d_0" -> "64 VGG/Sequential[features]/BatchNorm2d[21]/batch_norm_0"; +"62 features.21.weight" -> "64 VGG/Sequential[features]/BatchNorm2d[21]/batch_norm_0"; +"63 features.21.bias" -> "64 VGG/Sequential[features]/BatchNorm2d[21]/batch_norm_0"; +"64 VGG/Sequential[features]/BatchNorm2d[21]/batch_norm_0" -> "65 VGG/Sequential[features]/ReLU[22]/relu__0"; +"65 VGG/Sequential[features]/ReLU[22]/relu__0" -> "66 VGG/Sequential[features]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0"; +"66 VGG/Sequential[features]/ReLU[22]/SymmetricQuantizer/symmetric_quantize_0" -> "67 VGG/Sequential[features]/MaxPool2d[23]/max_pool2d_0"; +"67 VGG/Sequential[features]/MaxPool2d[23]/max_pool2d_0" -> "71 VGG/Sequential[features]/Conv2d[24]/conv2d_0"; +"68 features.24.weight" -> "70 VGG/Sequential[features]/Conv2d[24]/SymmetricQuantizer/symmetric_quantize_0"; +"69 features.24.bias" -> "71 VGG/Sequential[features]/Conv2d[24]/conv2d_0"; +"70 VGG/Sequential[features]/Conv2d[24]/SymmetricQuantizer/symmetric_quantize_0" -> "71 VGG/Sequential[features]/Conv2d[24]/conv2d_0"; +"71 VGG/Sequential[features]/Conv2d[24]/conv2d_0" -> "74 VGG/Sequential[features]/BatchNorm2d[25]/batch_norm_0"; +"72 features.25.weight" -> "74 VGG/Sequential[features]/BatchNorm2d[25]/batch_norm_0"; +"73 features.25.bias" -> "74 VGG/Sequential[features]/BatchNorm2d[25]/batch_norm_0"; +"74 VGG/Sequential[features]/BatchNorm2d[25]/batch_norm_0" -> "75 VGG/Sequential[features]/ReLU[26]/relu__0"; +"75 VGG/Sequential[features]/ReLU[26]/relu__0" -> "76 VGG/Sequential[features]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0"; +"76 VGG/Sequential[features]/ReLU[26]/SymmetricQuantizer/symmetric_quantize_0" -> "80 VGG/Sequential[features]/Conv2d[27]/conv2d_0"; +"77 features.27.weight" -> "79 VGG/Sequential[features]/Conv2d[27]/SymmetricQuantizer/symmetric_quantize_0"; +"78 features.27.bias" -> "80 VGG/Sequential[features]/Conv2d[27]/conv2d_0"; +"79 VGG/Sequential[features]/Conv2d[27]/SymmetricQuantizer/symmetric_quantize_0" -> "80 VGG/Sequential[features]/Conv2d[27]/conv2d_0"; +"80 VGG/Sequential[features]/Conv2d[27]/conv2d_0" -> "83 VGG/Sequential[features]/BatchNorm2d[28]/batch_norm_0"; +"81 features.28.weight" -> "83 VGG/Sequential[features]/BatchNorm2d[28]/batch_norm_0"; +"82 features.28.bias" -> "83 VGG/Sequential[features]/BatchNorm2d[28]/batch_norm_0"; +"83 VGG/Sequential[features]/BatchNorm2d[28]/batch_norm_0" -> "84 VGG/Sequential[features]/ReLU[29]/relu__0"; +"84 VGG/Sequential[features]/ReLU[29]/relu__0" -> "85 VGG/Sequential[features]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0"; +"85 VGG/Sequential[features]/ReLU[29]/SymmetricQuantizer/symmetric_quantize_0" -> "89 VGG/Sequential[features]/Conv2d[30]/conv2d_0"; +"86 features.30.weight" -> "88 VGG/Sequential[features]/Conv2d[30]/SymmetricQuantizer/symmetric_quantize_0"; +"87 features.30.bias" -> "89 VGG/Sequential[features]/Conv2d[30]/conv2d_0"; +"88 VGG/Sequential[features]/Conv2d[30]/SymmetricQuantizer/symmetric_quantize_0" -> "89 VGG/Sequential[features]/Conv2d[30]/conv2d_0"; +"89 VGG/Sequential[features]/Conv2d[30]/conv2d_0" -> "92 VGG/Sequential[features]/BatchNorm2d[31]/batch_norm_0"; +"90 features.31.weight" -> "92 VGG/Sequential[features]/BatchNorm2d[31]/batch_norm_0"; +"91 features.31.bias" -> "92 VGG/Sequential[features]/BatchNorm2d[31]/batch_norm_0"; +"92 VGG/Sequential[features]/BatchNorm2d[31]/batch_norm_0" -> "93 VGG/Sequential[features]/ReLU[32]/relu__0"; +"93 VGG/Sequential[features]/ReLU[32]/relu__0" -> "94 VGG/Sequential[features]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0"; +"94 VGG/Sequential[features]/ReLU[32]/SymmetricQuantizer/symmetric_quantize_0" -> "95 VGG/Sequential[features]/MaxPool2d[33]/max_pool2d_0"; +"95 VGG/Sequential[features]/MaxPool2d[33]/max_pool2d_0" -> "99 VGG/Sequential[features]/Conv2d[34]/conv2d_0"; +"96 features.34.weight" -> "98 VGG/Sequential[features]/Conv2d[34]/SymmetricQuantizer/symmetric_quantize_0"; +"97 features.34.bias" -> "99 VGG/Sequential[features]/Conv2d[34]/conv2d_0"; +"98 VGG/Sequential[features]/Conv2d[34]/SymmetricQuantizer/symmetric_quantize_0" -> "99 VGG/Sequential[features]/Conv2d[34]/conv2d_0"; +"99 VGG/Sequential[features]/Conv2d[34]/conv2d_0" -> "102 VGG/Sequential[features]/BatchNorm2d[35]/batch_norm_0"; +"100 features.35.weight" -> "102 VGG/Sequential[features]/BatchNorm2d[35]/batch_norm_0"; +"101 features.35.bias" -> "102 VGG/Sequential[features]/BatchNorm2d[35]/batch_norm_0"; +"102 VGG/Sequential[features]/BatchNorm2d[35]/batch_norm_0" -> "103 VGG/Sequential[features]/ReLU[36]/relu__0"; +"103 VGG/Sequential[features]/ReLU[36]/relu__0" -> "104 VGG/Sequential[features]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0"; +"104 VGG/Sequential[features]/ReLU[36]/SymmetricQuantizer/symmetric_quantize_0" -> "108 VGG/Sequential[features]/Conv2d[37]/conv2d_0"; +"105 features.37.weight" -> "107 VGG/Sequential[features]/Conv2d[37]/SymmetricQuantizer/symmetric_quantize_0"; +"106 features.37.bias" -> "108 VGG/Sequential[features]/Conv2d[37]/conv2d_0"; +"107 VGG/Sequential[features]/Conv2d[37]/SymmetricQuantizer/symmetric_quantize_0" -> "108 VGG/Sequential[features]/Conv2d[37]/conv2d_0"; +"108 VGG/Sequential[features]/Conv2d[37]/conv2d_0" -> "111 VGG/Sequential[features]/BatchNorm2d[38]/batch_norm_0"; +"109 features.38.weight" -> "111 VGG/Sequential[features]/BatchNorm2d[38]/batch_norm_0"; +"110 features.38.bias" -> "111 VGG/Sequential[features]/BatchNorm2d[38]/batch_norm_0"; +"111 VGG/Sequential[features]/BatchNorm2d[38]/batch_norm_0" -> "112 VGG/Sequential[features]/ReLU[39]/relu__0"; +"112 VGG/Sequential[features]/ReLU[39]/relu__0" -> "113 VGG/Sequential[features]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0"; +"113 VGG/Sequential[features]/ReLU[39]/SymmetricQuantizer/symmetric_quantize_0" -> "117 VGG/Sequential[features]/Conv2d[40]/conv2d_0"; +"114 features.40.weight" -> "116 VGG/Sequential[features]/Conv2d[40]/SymmetricQuantizer/symmetric_quantize_0"; +"115 features.40.bias" -> "117 VGG/Sequential[features]/Conv2d[40]/conv2d_0"; +"116 VGG/Sequential[features]/Conv2d[40]/SymmetricQuantizer/symmetric_quantize_0" -> "117 VGG/Sequential[features]/Conv2d[40]/conv2d_0"; +"117 VGG/Sequential[features]/Conv2d[40]/conv2d_0" -> "120 VGG/Sequential[features]/BatchNorm2d[41]/batch_norm_0"; +"118 features.41.weight" -> "120 VGG/Sequential[features]/BatchNorm2d[41]/batch_norm_0"; +"119 features.41.bias" -> "120 VGG/Sequential[features]/BatchNorm2d[41]/batch_norm_0"; +"120 VGG/Sequential[features]/BatchNorm2d[41]/batch_norm_0" -> "121 VGG/Sequential[features]/ReLU[42]/relu__0"; +"121 VGG/Sequential[features]/ReLU[42]/relu__0" -> "122 VGG/Sequential[features]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0"; +"122 VGG/Sequential[features]/ReLU[42]/SymmetricQuantizer/symmetric_quantize_0" -> "123 VGG/Sequential[features]/MaxPool2d[43]/max_pool2d_0"; +"123 VGG/Sequential[features]/MaxPool2d[43]/max_pool2d_0" -> "124 VGG/Sequential[features]/AvgPool2d[44]/avg_pool2d_0"; +"124 VGG/Sequential[features]/AvgPool2d[44]/avg_pool2d_0" -> "125 VGG/Sequential[features]/AvgPool2d[44]/SymmetricQuantizer/symmetric_quantize_0"; +"125 VGG/Sequential[features]/AvgPool2d[44]/SymmetricQuantizer/symmetric_quantize_0" -> "126 VGG/view_0"; +"126 VGG/view_0" -> "130 VGG/Linear[classifier]/linear_0"; +"127 classifier.weight" -> "129 VGG/Linear[classifier]/SymmetricQuantizer/symmetric_quantize_0"; +"128 classifier.bias" -> "130 VGG/Linear[classifier]/linear_0"; +"129 VGG/Linear[classifier]/SymmetricQuantizer/symmetric_quantize_0" -> "130 VGG/Linear[classifier]/linear_0"; +"130 VGG/Linear[classifier]/linear_0" -> "131 /nncf_model_output_0"; } diff --git a/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_disable.json b/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_disable.json index 47fad5258e0..c1dc5e6731a 100644 --- a/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_disable.json +++ b/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_disable.json @@ -1,5 +1,13 @@ { - "TwoConvTestModel/Sequential[features]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]": { + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[/nncf_model_input_0|OUTPUT]": { + "input_low": 0.0, + "input_high": 0.9970665574073792 + }, + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/Conv2d[0]/conv2d_0|OUTPUT]": { + "input_low": -3.8243322372436523, + "input_high": 3.794454574584961 + }, + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/Conv2d[0]/conv2d_0|INPUT1]": { "input_low": [ [ [ @@ -33,7 +41,7 @@ ] ] }, - "TwoConvTestModel/Sequential[features]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]": { + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[1]/Conv2d[0]/conv2d_0|INPUT1]": { "input_low": [ [ [ @@ -52,13 +60,5 @@ ] ] ] - }, - "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[/nncf_model_input_0|OUTPUT]": { - "input_low": 0.0, - "input_high": 0.9800970554351807 - }, - "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/NNCFConv2d[0]/conv2d_0|OUTPUT]": { - "input_low": -3.8243322372436523, - "input_high": 3.794454574584961 } } \ No newline at end of file diff --git a/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_enable.json b/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_enable.json index 2253a59ba08..c679824f317 100644 --- a/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_enable.json +++ b/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_enable.json @@ -1,5 +1,13 @@ { - "TwoConvTestModel/Sequential[features]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]": { + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[/nncf_model_input_0|OUTPUT]": { + "input_low": 0.0, + "input_high": 0.9970665574073792 + }, + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/Conv2d[0]/conv2d_0|OUTPUT]": { + "input_low": -3.8243322372436523, + "input_high": 3.794454574584961 + }, + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/Conv2d[0]/conv2d_0|INPUT1]": { "input_low": [ [ [ @@ -33,7 +41,7 @@ ] ] }, - "TwoConvTestModel/Sequential[features]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]": { + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[1]/Conv2d[0]/conv2d_0|INPUT1]": { "input_low": [ [ [ @@ -52,13 +60,5 @@ ] ] ] - }, - "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[/nncf_model_input_0|OUTPUT]": { - "input_low": 0.0, - "input_high": 0.9800970554351807 - }, - "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/NNCFConv2d[0]/conv2d_0|OUTPUT]": { - "input_low": -3.8243322372436523, - "input_high": 3.794454574584961 } } \ No newline at end of file diff --git a/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_first_layer_only.json b/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_first_layer_only.json index c004fb4ba61..708715926b7 100644 --- a/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_first_layer_only.json +++ b/tests/torch/data/reference_scales/TwoConvTestModel_overflow_fix_first_layer_only.json @@ -1,5 +1,13 @@ { - "TwoConvTestModel/Sequential[features]/Sequential[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]": { + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[/nncf_model_input_0|OUTPUT]": { + "input_low": 0.0, + "input_high": 0.9970665574073792 + }, + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/Conv2d[0]/conv2d_0|OUTPUT]": { + "input_low": -3.8243322372436523, + "input_high": 3.794454574584961 + }, + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/Conv2d[0]/conv2d_0|INPUT1]": { "input_low": [ [ [ @@ -33,7 +41,7 @@ ] ] }, - "TwoConvTestModel/Sequential[features]/Sequential[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]": { + "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[1]/Conv2d[0]/conv2d_0|INPUT1]": { "input_low": [ [ [ @@ -52,13 +60,5 @@ ] ] ] - }, - "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[/nncf_model_input_0|OUTPUT]": { - "input_low": 0.0, - "input_high": 0.9800970554351807 - }, - "TwoConvTestModel/NNCFNetworkInterface[_nncf]/ModuleDict[external_quantizers]/SymmetricQuantizer[TwoConvTestModel/Sequential[features]/Sequential[0]/NNCFConv2d[0]/conv2d_0|OUTPUT]": { - "input_low": -3.8243322372436523, - "input_high": 3.794454574584961 } } \ No newline at end of file diff --git a/tests/torch/helpers.py b/tests/torch/helpers.py index 3dfe3a3df7e..8e22f444e7e 100644 --- a/tests/torch/helpers.py +++ b/tests/torch/helpers.py @@ -566,20 +566,33 @@ def add_ref( """ Adds references hooks. """ - op_address = self._convert_to_op_address(target_type, target_node_name, input_port_id) + op_address = self._convert_to_op_address( + target_type, target_node_name, input_port_id, self._target_model.nncf.replace_modules + ) self._ref_hooks[target_type].update({op_address: ref_hooks}) - def _convert_to_op_address(self, target_type: TargetType, target_node_name: str, input_port_id: int) -> Any: + def _convert_to_op_address( + self, target_type: TargetType, target_node_name: str, input_port_id: int, replace_modules: bool + ) -> Any: address_map = self._target_model.nncf.get_node_to_op_address_mapping() address = address_map[target_node_name] - if target_type == TargetType.OPERATOR_PRE_HOOK: - address = PreHookId(address, input_port_id) - elif target_type in [ - TargetType.OPERATION_WITH_WEIGHTS, - TargetType.PRE_LAYER_OPERATION, - TargetType.POST_LAYER_OPERATION, - ]: - address = getattr(self._target_model, self._nncf_module_attr_name) + if replace_modules: + if target_type == TargetType.OPERATOR_PRE_HOOK: + address = PreHookId(address, input_port_id) + elif target_type in [ + TargetType.OPERATION_WITH_WEIGHTS, + TargetType.PRE_LAYER_OPERATION, + TargetType.POST_LAYER_OPERATION, + ]: + address = getattr(self._target_model, self._nncf_module_attr_name) + else: + if target_type in [TargetType.OPERATOR_PRE_HOOK, TargetType.OPERATION_WITH_WEIGHTS]: + address = PreHookId(address, input_port_id) + elif target_type in [ + TargetType.PRE_LAYER_OPERATION, + TargetType.POST_LAYER_OPERATION, + ]: + address = getattr(self._target_model, self._nncf_module_attr_name) return address def check_with_reference(self): diff --git a/tests/torch/ptq/helpers.py b/tests/torch/ptq/helpers.py index 54fdfa70710..7dd88540104 100644 --- a/tests/torch/ptq/helpers.py +++ b/tests/torch/ptq/helpers.py @@ -13,14 +13,13 @@ import torch -from nncf import NNCFConfig from nncf.common.graph.layer_attributes import ConvolutionLayerAttributes +from nncf.torch import wrap_model from nncf.torch.graph.graph import PTNNCFGraph -from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype +from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype from nncf.torch.graph.operator_metatypes import PTSumMetatype -from nncf.torch.model_creation import create_nncf_network from nncf.torch.tensor_statistics.statistics import PTMinMaxTensorStatistic from tests.post_training.test_templates.models import NNCFGraphToTest from tests.post_training.test_templates.models import NNCFGraphToTestDepthwiseConv @@ -54,7 +53,7 @@ def get_depthwise_conv_nncf_graph() -> NNCFGraphToTestDepthwiseConv: transpose=False, padding_values=(1, 1), ) - return NNCFGraphToTestDepthwiseConv(PTDepthwiseConv2dSubtype, conv_layer_attrs, nncf_graph_cls=PTNNCFGraph) + return NNCFGraphToTestDepthwiseConv(PTModuleDepthwiseConv2dSubtype, conv_layer_attrs, nncf_graph_cls=PTNNCFGraph) def get_single_no_weight_matmul_nncf_graph() -> NNCFGraphToTest: @@ -77,14 +76,11 @@ def get_sum_aggregation_nncf_graph() -> NNCFGraphToTestSumAggregation: def get_nncf_network(model: torch.nn.Module, input_shape: Optional[List[int]] = None): - input_shape = [1, 3, 32, 32] if input_shape is None else input_shape - model.eval() - nncf_config = NNCFConfig({"input_info": {"sample_size": input_shape.copy()}}) - nncf_network = create_nncf_network( - model=model, - config=nncf_config, - ) - return nncf_network + if input_shape is None: + input_shape = [1, 3, 32, 32] + model = model.eval() + device = next(model.named_parameters())[1].device + return wrap_model(model, torch.ones(input_shape).to(device=device), trace_parameters=True) def mock_collect_statistics(mocker): diff --git a/tests/torch/ptq/test_calculation_quantizer_params.py b/tests/torch/ptq/test_calculation_quantizer_params.py index 5c08d137815..234c05e6de8 100644 --- a/tests/torch/ptq/test_calculation_quantizer_params.py +++ b/tests/torch/ptq/test_calculation_quantizer_params.py @@ -19,7 +19,6 @@ from torch import nn from nncf import Dataset -from nncf import NNCFConfig from nncf.common.graph.transformations.commands import TargetType from nncf.common.quantization.structs import QuantizationPreset from nncf.common.quantization.structs import QuantizationScheme as QuantizationMode @@ -32,7 +31,7 @@ from nncf.quantization.fake_quantize import FakeQuantizeParameters from nncf.quantization.fake_quantize import calculate_quantizer_parameters from nncf.quantization.fake_quantize import get_quantizer_narrow_range -from nncf.torch.model_creation import create_nncf_network +from nncf.torch.model_creation import wrap_model from nncf.torch.statistics.aggregator import PTStatisticsAggregator from nncf.torch.tensor_statistics.statistics import PTMinMaxTensorStatistic from tests.post_training.test_templates.test_calculate_quantizer_parameters import TemplateTestFQParams @@ -290,17 +289,17 @@ def calculate_fq_params(model, input_data): conv2_w_stats = calculate_statistics(conv2_w, QuantizationMode.SYMMETRIC, QuantizerGroup.WEIGHTS) return { "//nncf_model_input_0|OUTPUT/FakeQuantize": conv1_stats, - "/bn1/LinearTestModel/NNCFBatchNorm2d[bn1]/batch_norm_0|INPUT0/FakeQuantize": bn1_stats, + "/bn1/LinearTestModel/BatchNorm2d[bn1]/batch_norm_0|INPUT0/FakeQuantize": bn1_stats, "/avg_pool/LinearTestModel/AdaptiveAvgPool2d[avg_pool]/adaptive_avg_pool2d_0|INPUT0/FakeQuantize": ( avg_pool_stats ), - "/conv2/LinearTestModel/NNCFConv2d[conv2]/conv2d_0|INPUT0/FakeQuantize": conv2_stats, - "/conv1/pre_ops.0/op/FakeQuantize": conv1_w_stats, - "/conv2/pre_ops.0/op/FakeQuantize": conv2_w_stats, + "/conv2/LinearTestModel/Conv2d[conv2]/conv2d_0|INPUT0/FakeQuantize": conv2_stats, + "/conv1/LinearTestModel/Conv2d[conv1]/conv2d_0|INPUT1/FakeQuantize": conv1_w_stats, + "/conv2/LinearTestModel/Conv2d[conv2]/conv2d_0|INPUT1/FakeQuantize": conv2_w_stats, } -def test_quantizer_parameters_export(tmp_path: Path): +def test_quantizer_parameters_export(tmp_path: Path, _seed): model = LinearTestModel() model.eval().cpu() @@ -312,8 +311,7 @@ def test_quantizer_parameters_export(tmp_path: Path): min_max_algo = MinMaxQuantization(subset_size=1, preset=QuantizationPreset.PERFORMANCE, inplace_statistics=False) statistics_aggregator = PTStatisticsAggregator(dataset) - nncf_config = NNCFConfig({"input_info": {"sample_size": [1, 3, 32, 32]}}) - nncf_network = create_nncf_network(model, nncf_config) + nncf_network = wrap_model(model, torch.ones([1, 3, 32, 32]), True) statistic_points = min_max_algo.get_statistic_points(nncf_network, nncf_network.nncf.get_graph()) statistics_aggregator.register_statistic_points(statistic_points) statistics_aggregator.collect_statistics(model, nncf_network.nncf.get_graph()) diff --git a/tests/torch/ptq/test_fast_bias_correction.py b/tests/torch/ptq/test_fast_bias_correction.py index 6bbdc342e0b..a92a8a7739b 100644 --- a/tests/torch/ptq/test_fast_bias_correction.py +++ b/tests/torch/ptq/test_fast_bias_correction.py @@ -16,8 +16,8 @@ from nncf.common.factory import NNCFGraphFactory from nncf.quantization.algorithms.fast_bias_correction.torch_backend import PTFastBiasCorrectionAlgoBackend -from nncf.torch.model_analyzer import get_fused_bias_value -from nncf.torch.model_analyzer import is_node_with_fused_bias +from nncf.torch.model_graph_manager import get_fused_bias_value +from nncf.torch.model_graph_manager import is_node_with_fused_bias from nncf.torch.nncf_network import NNCFNetwork from tests.post_training.test_templates.test_fast_bias_correction import TemplateTestFBCAlgorithm from tests.torch.ptq.helpers import get_nncf_network diff --git a/tests/torch/ptq/test_fq_params_calculation.py b/tests/torch/ptq/test_fq_params_calculation.py index dba3df8ef21..0a3b537df1d 100644 --- a/tests/torch/ptq/test_fq_params_calculation.py +++ b/tests/torch/ptq/test_fq_params_calculation.py @@ -20,8 +20,8 @@ from nncf.quantization.advanced_parameters import AdvancedSmoothQuantParameters from nncf.quantization.advanced_parameters import OverflowFix from nncf.quantization.algorithms.post_training.algorithm import PostTrainingQuantization +from nncf.torch import wrap_model from nncf.torch.dynamic_graph.scope import Scope -from nncf.torch.model_creation import create_nncf_network from nncf.torch.nncf_network import NNCFNetwork from nncf.torch.quantization.layers import QUANTIZATION_MODULES from nncf.torch.utils import get_all_modules_by_type @@ -57,7 +57,7 @@ def transform_fn(sample): post_training_quantization = PostTrainingQuantization(subset_size=1, **quantization_params) original_model.eval() - nncf_network = create_nncf_network(original_model, config) + nncf_network = wrap_model(original_model, torch.ones([1, 1, 10, 10]), trace_parameters=True) quantized_model = post_training_quantization.apply(nncf_network, nncf_network.nncf.get_graph(), dataset=dataset) return quantized_model @@ -97,7 +97,7 @@ def test_overflow_fix_scales(_seed, overflow_fix): ref_stats_name = "TwoConvTestModel" + f"_overflow_fix_{overflow_fix.value}.json" ref_stats_path = REFERENCE_SCALES_DIR / ref_stats_name - # Unkomment lines below to generate reference for new models. + # Uncomment lines below to generate reference for new models. # from tests.shared.helpers import dump_to_json # dump_to_json(ref_stats_path, fq_nodes_params) diff --git a/tests/torch/ptq/test_graphs.py b/tests/torch/ptq/test_graphs.py index d441b5b04e1..ee59703d3ed 100644 --- a/tests/torch/ptq/test_graphs.py +++ b/tests/torch/ptq/test_graphs.py @@ -13,16 +13,17 @@ from pathlib import Path import pytest +import torch from nncf.parameters import TargetDevice from nncf.quantization.advanced_parameters import AdvancedQuantizationParameters from nncf.quantization.algorithms.post_training.algorithm import PostTrainingQuantization +from nncf.torch import wrap_model from nncf.torch.layers import NNCF_RNN from nncf.torch.layers import LSTMCellNNCF from tests.post_training.test_templates.helpers import EmbeddingModel from tests.post_training.test_templates.helpers import get_static_dataset from tests.torch import test_models -from tests.torch.ptq.helpers import get_nncf_network from tests.torch.ptq.helpers import mock_collect_statistics from tests.torch.quantization.test_algo_quantization import SharedLayersModel from tests.torch.test_compressed_graph import ModelDesc @@ -97,7 +98,7 @@ def test_min_max_classification_quantized_graphs(desc: ModelDesc, quantization_p mock_collect_statistics(mocker) model = desc.model_builder() - nncf_network = get_nncf_network(model, desc.input_sample_sizes) + nncf_network = wrap_model(model, torch.ones(desc.input_sample_sizes), trace_parameters=True) quantization_parameters["advanced_parameters"] = AdvancedQuantizationParameters(disable_bias_correction=True) quantization_algorithm = PostTrainingQuantization(**quantization_parameters) diff --git a/tests/torch/ptq/test_ptq_params.py b/tests/torch/ptq/test_ptq_params.py index 88a691c47fc..7404c211002 100644 --- a/tests/torch/ptq/test_ptq_params.py +++ b/tests/torch/ptq/test_ptq_params.py @@ -25,8 +25,8 @@ from nncf.torch.graph.graph import PTNNCFGraph from nncf.torch.graph.graph import PTTargetPoint from nncf.torch.graph.operator_metatypes import PTCatMetatype -from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype -from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype +from nncf.torch.graph.operator_metatypes import PTConv2dMetatype +from nncf.torch.graph.operator_metatypes import PTLinearMetatype from nncf.torch.graph.operator_metatypes import PTSoftmaxMetatype from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand from tests.common.quantization.metatypes import CatTestMetatype @@ -121,8 +121,8 @@ def get_backend_tensor(self, value): @property def metatypes_mapping(self): return { - Conv2dTestMetatype: PTModuleConv2dMetatype, - LinearTestMetatype: PTModuleLinearMetatype, + Conv2dTestMetatype: PTConv2dMetatype, + LinearTestMetatype: PTLinearMetatype, SoftmaxTestMetatype: PTSoftmaxMetatype, CatTestMetatype: PTCatMetatype, } diff --git a/tests/torch/ptq/test_smooth_quant.py b/tests/torch/ptq/test_smooth_quant.py index 7af4fa98d33..f434df7a2ab 100644 --- a/tests/torch/ptq/test_smooth_quant.py +++ b/tests/torch/ptq/test_smooth_quant.py @@ -19,8 +19,8 @@ from nncf.common.graph.transformations.commands import TransformationCommand from nncf.quantization.algorithms.smooth_quant.torch_backend import PTSmoothQuantAlgoBackend from nncf.quantization.algorithms.smooth_quant.torch_backend import SQMultiply -from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype -from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype +from nncf.torch.graph.operator_metatypes import PTConv2dMetatype +from nncf.torch.graph.operator_metatypes import PTLinearMetatype from nncf.torch.graph.transformations.commands import ExtraCompressionModuleType from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand from nncf.torch.model_creation import wrap_model @@ -36,15 +36,15 @@ } PT_LINEAR_MODEL_MM_MAP = { - "Linear1": "LinearMultiShapeModel/NNCFLinear[linear_2]/linear_0", - "Linear2": "LinearMultiShapeModel/NNCFLinear[linear_1]/linear_0", - "Linear3": "LinearMultiShapeModel/NNCFLinear[linear_3]/linear_0", - "Linear4": "LinearMultiShapeModel/NNCFLinear[linear_4]/linear_0", + "Linear1": "LinearMultiShapeModel/Linear[linear_2]/linear_0", + "Linear2": "LinearMultiShapeModel/Linear[linear_1]/linear_0", + "Linear3": "LinearMultiShapeModel/Linear[linear_3]/linear_0", + "Linear4": "LinearMultiShapeModel/Linear[linear_4]/linear_0", } PT_CONV_MODEL_SQ_MAP = {("Conv1",): "/nncf_model_input_0_0_0/nncf_smooth_quant"} -PT_CONV_MODEL_MM_MAP = {"Conv1": "ConvTestModel/NNCFConv2d[conv]/conv2d_0"} +PT_CONV_MODEL_MM_MAP = {"Conv1": "ConvTestModel/Conv2d[conv]/conv2d_0"} class TestTorchSQAlgorithm(TemplateTestSQAlgorithm): @@ -84,7 +84,7 @@ def get_backend() -> Type[PTSmoothQuantAlgoBackend]: @staticmethod def backend_specific_model(model: torch.nn.Module, tmp_dir: str) -> ov.Model: - return wrap_model(model.eval(), torch.rand(model.INPUT_SIZE)) + return wrap_model(model.eval(), torch.rand(model.INPUT_SIZE), trace_parameters=True) @staticmethod def check_scales(model: torch.nn.Module, reference_values: Dict[str, np.ndarray], model_cls) -> None: @@ -107,8 +107,8 @@ def check_scales(model: torch.nn.Module, reference_values: Dict[str, np.ndarray] @pytest.mark.parametrize( "node_metatype, layer_attributes, port_id, reference_value", ( - (PTModuleLinearMetatype, None, 0, -1), - (PTModuleConv2dMetatype, None, 0, 1), + (PTLinearMetatype, None, 0, -1), + (PTConv2dMetatype, None, 0, 1), ), ) def test_get_activation_channel_axis(self, node_metatype, layer_attributes, port_id, reference_value): @@ -117,8 +117,8 @@ def test_get_activation_channel_axis(self, node_metatype, layer_attributes, port @pytest.mark.parametrize( "node_metatype, layer_attributes, reference_value", ( - (PTModuleLinearMetatype, None, 1), - (PTModuleConv2dMetatype, None, 1), + (PTLinearMetatype, None, 1), + (PTConv2dMetatype, None, 1), ), ) def test_get_weight_channel_axis(self, node_metatype, layer_attributes, reference_value): @@ -126,4 +126,4 @@ def test_get_weight_channel_axis(self, node_metatype, layer_attributes, referenc @staticmethod def get_matmul_metatype(): - return PTModuleLinearMetatype + return PTLinearMetatype diff --git a/tests/torch/ptq/test_strip.py b/tests/torch/ptq/test_strip.py index af856b726c5..a767ad7a05b 100644 --- a/tests/torch/ptq/test_strip.py +++ b/tests/torch/ptq/test_strip.py @@ -35,5 +35,5 @@ def test_nncf_strip_api(strip_type, do_copy): else: assert id(strip_model) == id(quantized_model) - assert isinstance(strip_model.conv.get_pre_op("0").op, FakeQuantize) - assert isinstance(strip_model.nncf.external_quantizers["/nncf_model_input_0|OUTPUT"], FakeQuantize) + for fq in strip_model.nncf.external_quantizers.values(): + assert isinstance(fq, FakeQuantize) diff --git a/tests/torch/test_layer_attributes.py b/tests/torch/test_layer_attributes.py index a2d82141a9b..4bfd6d503ab 100644 --- a/tests/torch/test_layer_attributes.py +++ b/tests/torch/test_layer_attributes.py @@ -25,6 +25,7 @@ from nncf.common.graph.layer_attributes import PermuteLayerAttributes from nncf.common.graph.layer_attributes import ReshapeLayerAttributes from nncf.common.graph.layer_attributes import TransposeLayerAttributes +from nncf.common.graph.layer_attributes import WeightedLayerAttributes from nncf.common.graph.operator_metatypes import OperatorMetatype from nncf.torch import wrap_model from nncf.torch.dynamic_graph.graph_tracer import create_dummy_forward_fn @@ -41,6 +42,7 @@ from nncf.torch.graph.operator_metatypes import PTConvTranspose1dMetatype from nncf.torch.graph.operator_metatypes import PTConvTranspose2dMetatype from nncf.torch.graph.operator_metatypes import PTConvTranspose3dMetatype +from nncf.torch.graph.operator_metatypes import PTDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTEmbeddingBagMetatype from nncf.torch.graph.operator_metatypes import PTEmbeddingMetatype from nncf.torch.graph.operator_metatypes import PTGatherMetatype @@ -182,7 +184,7 @@ def __str__(self): padding_values=(0, 0), with_bias=True, ), - metatype_cls=PTConv2dMetatype, + metatype_cls=PTDepthwiseConv2dSubtype, ), LayerAttributesTestDesc( module_fn=lambda: nn.Conv1d(1, 2, 1), @@ -551,6 +553,10 @@ def test_can_set_valid_layer_attributes_wrap_model(desc: LayerAttributesTestDesc ] assert ref_values == actual_values + if isinstance(desc.layer_attributes, WeightedLayerAttributes): + assert hasattr(desc.metatype_cls, "weight_port_ids") + assert len(desc.metatype_cls.weight_port_ids) > 0 + @pytest.mark.parametrize( "signature, args, kwargs", diff --git a/tests/torch/test_model_analyzer.py b/tests/torch/test_model_analyzer.py deleted file mode 100644 index 6e4e9b14fe5..00000000000 --- a/tests/torch/test_model_analyzer.py +++ /dev/null @@ -1,67 +0,0 @@ -# Copyright (c) 2024 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 -import torch - -from nncf.torch import wrap_model -from nncf.torch.model_analyzer import get_fused_bias_value -from nncf.torch.model_transformer import update_fused_bias -from tests.post_training.test_templates.helpers import ConvBiasBNTestModel -from tests.post_training.test_templates.helpers import ConvBNTestModel -from tests.post_training.test_templates.helpers import ConvTestModel - - -@pytest.mark.parametrize( - "model_cls, ref", - ( - (ConvTestModel, [0.1000, 1.0000]), # conv.bias - (ConvBNTestModel, [0.1000, 1.0000]), # bn.bias - (ConvBiasBNTestModel, [0.1600, 3.6000]), # conv.bias*bn.weight + bn.bias - ), -) -def test_get_fused_bias_value(model_cls, ref): - model = wrap_model(model_cls(), torch.ones(model_cls.INPUT_SIZE)) - - graph = model.nncf.get_graph() - target_node = graph.get_nodes_by_types("conv2d")[0] - - bias = get_fused_bias_value(target_node, model) - assert torch.all(torch.isclose(bias, torch.tensor(ref))) - - -@pytest.mark.parametrize( - "model_cls", - ( - (ConvTestModel), # conv.bias - (ConvBNTestModel), # bn.bias - (ConvBiasBNTestModel), # conv.bias*bn.weight + bn.bias - ), -) -def test_update_fused_bias(model_cls): - model = wrap_model(model_cls(), torch.ones(model_cls.INPUT_SIZE)) - ref_new_bias = torch.tensor([-1.0, -1.0]) - graph = model.nncf.get_graph() - target_node = graph.get_nodes_by_types("conv2d")[0] - - update_fused_bias(target_node.node_name, ref_new_bias, model) - bias = get_fused_bias_value(target_node, model) - assert torch.all(torch.isclose(bias, ref_new_bias)) - - if model_cls == ConvTestModel: - assert torch.all(torch.isclose(model.conv.bias, ref_new_bias)) - if model_cls == ConvBNTestModel: - assert model.conv.bias is None - assert torch.all(torch.isclose(model.bn.bias, ref_new_bias)) - if model_cls == ConvBiasBNTestModel: - assert torch.all(torch.isclose(model.conv.bias, torch.tensor([0.3000, 1.3000]))) - assert torch.all(torch.isclose(model.bn.bias, torch.tensor([-1.0600, -3.6000]))) - assert torch.all(torch.isclose(model.conv.bias * model.bn.weight + model.bn.bias, ref_new_bias)) diff --git a/tests/torch/test_model_graph_manager.py b/tests/torch/test_model_graph_manager.py index f1d9d743591..8d413533b01 100644 --- a/tests/torch/test_model_graph_manager.py +++ b/tests/torch/test_model_graph_manager.py @@ -27,6 +27,7 @@ from nncf.torch.model_graph_manager import get_const_data_on_port from nncf.torch.model_graph_manager import get_const_node from nncf.torch.model_graph_manager import get_fake_quantizer +from nncf.torch.model_graph_manager import get_fused_bias_value from nncf.torch.model_graph_manager import get_module_by_name from nncf.torch.model_graph_manager import get_potential_fused_node from nncf.torch.model_graph_manager import get_weight_tensor_port_ids @@ -34,6 +35,7 @@ from nncf.torch.model_graph_manager import is_quantized_weights from nncf.torch.model_graph_manager import set_const_data from nncf.torch.model_graph_manager import split_const_name +from nncf.torch.model_graph_manager import update_fused_bias from nncf.torch.model_transformer import PTModelTransformer from nncf.torch.model_transformer import PTTransformationLayout from nncf.torch.nncf_network import NNCFNetwork @@ -313,3 +315,50 @@ def test_is_quantized_weights(): q_graph = q_model.nncf.get_graph() q_node = q_graph.get_node_by_name(node_name) assert is_quantized_weights(q_node, q_graph) + + +@pytest.mark.parametrize( + "model_cls, ref", + ( + (helpers.ConvTestModel, [0.1000, 1.0000]), # conv.bias + (helpers.ConvBNTestModel, [0.1000, 1.0000]), # bn.bias + (helpers.ConvBiasBNTestModel, [0.1600, 3.6000]), # conv.bias*bn.weight + bn.bias + ), +) +def test_get_fused_bias_value(model_cls, ref): + model = wrap_model(model_cls(), torch.ones(model_cls.INPUT_SIZE), trace_parameters=True) + + graph = model.nncf.get_graph() + target_node = graph.get_nodes_by_types("conv2d")[0] + + bias = get_fused_bias_value(target_node, model) + assert torch.all(torch.isclose(bias, torch.tensor(ref))) + + +@pytest.mark.parametrize( + "model_cls", + ( + (helpers.ConvTestModel), # conv.bias + (helpers.ConvBNTestModel), # bn.bias + (helpers.ConvBiasBNTestModel), # conv.bias*bn.weight + bn.bias + ), +) +def test_update_fused_bias(model_cls): + model = wrap_model(model_cls(), torch.ones(model_cls.INPUT_SIZE), trace_parameters=True) + ref_new_bias = torch.tensor([-1.0, -1.0]) + graph = model.nncf.get_graph() + target_node = graph.get_nodes_by_types("conv2d")[0] + + update_fused_bias(target_node.node_name, ref_new_bias, model) + bias = get_fused_bias_value(target_node, model) + assert torch.all(torch.isclose(bias, ref_new_bias)) + + if model_cls == helpers.ConvTestModel: + assert torch.all(torch.isclose(model.conv.bias, ref_new_bias)) + if model_cls == helpers.ConvBNTestModel: + assert model.conv.bias is None + assert torch.all(torch.isclose(model.bn.bias, ref_new_bias)) + if model_cls == helpers.ConvBiasBNTestModel: + assert torch.all(torch.isclose(model.conv.bias, torch.tensor([0.3000, 1.3000]))) + assert torch.all(torch.isclose(model.bn.bias, torch.tensor([-1.0600, -3.6000]))) + assert torch.all(torch.isclose(model.conv.bias * model.bn.weight + model.bn.bias, ref_new_bias)) diff --git a/tests/torch/test_model_transformer.py b/tests/torch/test_model_transformer.py index c554a39ccb3..79944696593 100644 --- a/tests/torch/test_model_transformer.py +++ b/tests/torch/test_model_transformer.py @@ -44,7 +44,6 @@ from nncf.torch.dynamic_graph.operation_address import OperationAddress from nncf.torch.dynamic_graph.patch_pytorch import register_operator from nncf.torch.external_hook import ExternalOpCallHook -from nncf.torch.graph.operator_metatypes import PTConv2dMetatype from nncf.torch.graph.operator_metatypes import PTInputNoopMetatype from nncf.torch.graph.operator_metatypes import PTModuleConv2dMetatype from nncf.torch.graph.operator_metatypes import PTOutputNoopMetatype @@ -54,12 +53,11 @@ from nncf.torch.graph.transformations.commands import ExtraCompressionModuleType from nncf.torch.graph.transformations.commands import PTBiasCorrectionCommand from nncf.torch.graph.transformations.commands import PTInsertionCommand -from nncf.torch.graph.transformations.commands import PTModelExtractionWithFusedBiasCommand +from nncf.torch.graph.transformations.commands import PTModelExtractionCommand from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand from nncf.torch.graph.transformations.commands import PTTargetPoint from nncf.torch.graph.transformations.commands import PTWeightUpdateCommand from nncf.torch.graph.transformations.layout import PTTransformationLayout -from nncf.torch.layers import NNCFConv2d from nncf.torch.layers import register_module from nncf.torch.model_transformer import PTModelTransformer from nncf.torch.module_operations import BaseOp @@ -474,6 +472,7 @@ def test_operator_metatype_marking(self): from nncf.torch.graph.operator_metatypes import PTMaxPool2dMetatype from nncf.torch.graph.operator_metatypes import PTModuleBatchNormMetatype from nncf.torch.graph.operator_metatypes import PTModuleConvTranspose2dMetatype + from nncf.torch.graph.operator_metatypes import PTModuleDepthwiseConv2dSubtype from nncf.torch.graph.operator_metatypes import PTModuleLinearMetatype from nncf.torch.graph.operator_metatypes import PTRELUMetatype from nncf.torch.graph.operator_metatypes import PTTransposeMetatype @@ -491,8 +490,8 @@ def test_operator_metatype_marking(self): ), "ModelForMetatypeTesting/conv_transpose2d_0": PTConvTranspose2dMetatype, "ModelForMetatypeTesting/__add___0": PTAddMetatype, - "ModelForMetatypeTesting/NNCFConv2d[conv_depthwise]/conv2d_0": PTDepthwiseConv2dSubtype, - "ModelForMetatypeTesting/conv2d_0": PTConv2dMetatype, + "ModelForMetatypeTesting/NNCFConv2d[conv_depthwise]/conv2d_0": PTModuleDepthwiseConv2dSubtype, + "ModelForMetatypeTesting/conv2d_0": PTDepthwiseConv2dSubtype, "ModelForMetatypeTesting/__iadd___0": PTAddMetatype, "ModelForMetatypeTesting/AdaptiveAvgPool2d[adaptive_avg_pool]/adaptive_avg_pool2d_0": PTAvgPool2dMetatype, "ModelForMetatypeTesting/flatten_0": PTReshapeMetatype, @@ -572,18 +571,16 @@ def test_get_ip_graph_with_merged_operations(self, mock_graph_factory, dot_file_ assert Counter(sanitized_loaded_edges) == Counter(list(merged_ip_graph.edges)) -def test_extraction_with_fused_bias_transformations(): - model = NNCFNetwork(InsertionPointTestModel(), FillerInputInfo([FillerInputElement([1, 1, 10, 10])])) +def test_extraction_model_transformations(): + model = wrap_model(InsertionPointTestModel(), torch.ones([1, 1, 10, 10]), trace_parameters=True) model_transformer = PTModelTransformer(model) - command = PTModelExtractionWithFusedBiasCommand("InsertionPointTestModel/NNCFConv2d[conv1]/conv2d_0") + command = PTModelExtractionCommand( + ["InsertionPointTestModel/Conv2d[conv1]/conv2d_0"], ["InsertionPointTestModel/Conv2d[conv1]/conv2d_0"] + ) transformation_layout = PTTransformationLayout() transformation_layout.register(command) - extracted_model = model_transformer.transform(transformation_layout) - - assert isinstance(extracted_model, nn.Sequential) - assert len(extracted_model) == 1 - assert isinstance(extracted_model[0], NNCFConv2d) + model_transformer.transform(transformation_layout) @pytest.mark.parametrize( @@ -591,10 +588,10 @@ def test_extraction_with_fused_bias_transformations(): [(PTBiasCorrectionCommand, "bias", torch.tensor([42.0])), (PTWeightUpdateCommand, "weight", torch.tensor([42.0]))], ) def test_correction_transformations(command_cls, attr_name, new_value): - model = NNCFNetwork(InsertionPointTestModel(), FillerInputInfo([FillerInputElement([1, 1, 10, 10])])) + model = wrap_model(InsertionPointTestModel(), torch.ones([1, 1, 10, 10]), trace_parameters=True) model_transformer = PTModelTransformer(model) - target_point = PTTargetPoint(TargetType.LAYER, "InsertionPointTestModel/NNCFConv2d[conv1]/conv2d_0") + target_point = PTTargetPoint(TargetType.LAYER, "InsertionPointTestModel/Conv2d[conv1]/conv2d_0") command = command_cls(target_point, new_value) transformation_layout = PTTransformationLayout() @@ -660,18 +657,14 @@ def to(self, device): def test_create_quantizer_insertion_command(target_point): hook = Hook() command = create_quantizer_insertion_command(target_point, hook) - assert command.fn is hook - if target_point.type is TargetType.OPERATION_WITH_WEIGHTS: - assert isinstance(command, PTInsertionCommand) - else: - quantizer_id = NonWeightQuantizerId(target_point.target_node_name, target_point.input_port_id) - assert isinstance(command, PTSharedFnInsertionCommand) - assert command.target_points == [target_point] - assert command.fn is hook - storage_key = str(quantizer_id) - assert command.op_name == storage_key - assert command.compression_module_type is ExtraCompressionModuleType.EXTERNAL_QUANTIZER + quantizer_id = NonWeightQuantizerId(target_point.target_node_name, target_point.input_port_id) + assert isinstance(command, PTSharedFnInsertionCommand) + assert command.target_points == [target_point] + assert command.fn is hook + storage_key = str(quantizer_id) + assert command.op_name == storage_key + assert command.compression_module_type is ExtraCompressionModuleType.EXTERNAL_QUANTIZER def test_create_shared_quantizer_insertion_command(): diff --git a/tests/torch/test_statistics_aggregator.py b/tests/torch/test_statistics_aggregator.py index a5c8a71788e..01f927fcb83 100644 --- a/tests/torch/test_statistics_aggregator.py +++ b/tests/torch/test_statistics_aggregator.py @@ -9,7 +9,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import List, Type +from typing import Callable, List, Type import numpy as np import pytest @@ -38,7 +38,7 @@ from tests.torch.ptq.test_ptq_params import ToNNCFNetworkInterface IDENTITY_NODE_NAME = "PTIdentityConvModel/__add___0" -CONV_NODE_NAME = "PTIdentityConvModel/NNCFConv2d[conv]/conv2d_0" +CONV_NODE_NAME = "PTIdentityConvModel/Conv2d[conv]/conv2d_0" INPUT_SHAPE = [1, 3, 3, 3] @@ -97,7 +97,7 @@ def get_target_point(target_type: TargetType): port_id = 0 if target_type == TargetType.OPERATION_WITH_WEIGHTS: target_node_name = CONV_NODE_NAME - port_id = None + port_id = 1 return PTMinMaxAlgoBackend.target_point(target_type, target_node_name, port_id) def get_target_point_cls(self): @@ -191,7 +191,7 @@ def fn(x): model = self.__add_fn_to_model(model, target_point, fn) # Check hook inserted correctly - self.__check_successive_hooks(test_parameters, model, target_point, fn) + self.__check_successive_hooks(model, target_point, fn) # Register and collect statistics after inserted operations statistic_points = self.__get_statistic_points( @@ -206,7 +206,7 @@ def fn(x): ) # Check the inserted operation is inside the model - self.__check_successive_hooks(test_parameters, model, target_point, fn) + self.__check_successive_hooks(model, target_point, fn) @pytest.mark.parametrize( "test_parameters, nested_target_node_name", @@ -231,7 +231,7 @@ def fn(x): 512, -512, ), - "PTIdentityConvModel/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/fn_0", + "PTIdentityConvModel/Conv2d[conv]/fn_0", ), ( MinMaxTestParameters( @@ -281,7 +281,7 @@ def fn(x): model = self.__add_fn_to_model(model, nested_target_point, fn) # Check hook inserted correctly - self.__check_nested_hooks(test_parameters, model, target_point, nested_target_type, nested_target_node_name, fn) + self.__check_nested_hooks(model, target_point, nested_target_type, nested_target_node_name, fn) # Register and collect statistics after inserted operations statistic_points = self.__get_statistic_points( @@ -296,7 +296,7 @@ def fn(x): ) # Check the inserted operation is inside the model - self.__check_nested_hooks(test_parameters, model, target_point, nested_target_type, nested_target_node_name, fn) + self.__check_nested_hooks(model, target_point, nested_target_type, nested_target_node_name, fn) @staticmethod def __add_fn_to_model(model, target_point, fn): @@ -367,26 +367,34 @@ def __check_collector(test_parameters, tensor_collector, stat_in_shape_of_scale) assert stat.max_values.shape == ref_shape @staticmethod - def __check_successive_hooks(test_parameters, model, target_point, fn): + def __check_successive_hooks(model: nn.Module, target_point: PTTargetPoint, fn: Callable): checker = HookChecker(model, "conv") checker.add_ref( ref_hooks=[fn], - target_type=test_parameters.target_type, + target_type=TargetType.OPERATOR_PRE_HOOK + if target_point.target_type == TargetType.OPERATION_WITH_WEIGHTS + else target_point.target_type, target_node_name=target_point.target_node_name, - input_port_id=0, + input_port_id=target_point.input_port_id, ) checker.check_with_reference() @staticmethod def __check_nested_hooks( - test_parameters, model, target_point, nested_target_type: TargetType, nested_target_node_name: str, fn + model: nn.Module, + target_point: PTTargetPoint, + nested_target_type: TargetType, + nested_target_node_name: str, + fn: Callable, ): checker = HookChecker(model, "conv") checker.add_ref( ref_hooks=[fn], - target_type=test_parameters.target_type, + target_type=TargetType.OPERATOR_PRE_HOOK + if target_point.target_type == TargetType.OPERATION_WITH_WEIGHTS + else target_point.target_type, target_node_name=target_point.target_node_name, - input_port_id=0, + input_port_id=target_point.input_port_id, ) checker.add_ref( ref_hooks=[fn], From 9c7a2124f3d6e918c0b5cdfdd18896576b53b9b4 Mon Sep 17 00:00:00 2001 From: Alexander Dokuchaev Date: Wed, 24 Apr 2024 11:39:42 +0300 Subject: [PATCH 10/12] [OV] Speedup precommit tests (#2650) ### Changes Use `ubuntu-20.04-8-cores` runner Run tests in parallel by xdist (12 vs 37 mins) Add summary `-ra` to show list of not passed tests (skip, xfail, fail) --- .github/workflows/precommit.yml | 2 +- Makefile | 2 +- tests/openvino/native/test_model_transformer.py | 3 ++- tests/openvino/requirements.txt | 1 + 4 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/precommit.yml b/.github/workflows/precommit.yml index 2a763b91256..b957670cb54 100644 --- a/.github/workflows/precommit.yml +++ b/.github/workflows/precommit.yml @@ -64,7 +64,7 @@ jobs: name: coverage_onnx flags: ONNX openvino: - runs-on: ubuntu-20.04 + runs-on: ubuntu-20.04-8-cores steps: - uses: actions/checkout@v3 with: diff --git a/Makefile b/Makefile index 545d35ec4f2..50b81427310 100644 --- a/Makefile +++ b/Makefile @@ -74,7 +74,7 @@ install-openvino-dev: install-openvino-test install-pre-commit pip install -r examples/post_training_quantization/openvino/yolov8_quantize_with_accuracy_control/requirements.txt test-openvino: - ONEDNN_MAX_CPU_ISA=AVX2 pytest ${COVERAGE_ARGS} tests/openvino $(DATA_ARG) --junitxml ${JUNITXML_PATH} + ONEDNN_MAX_CPU_ISA=AVX2 pytest ${COVERAGE_ARGS} -n4 -ra tests/openvino $(DATA_ARG) --junitxml ${JUNITXML_PATH} test-install-openvino: pytest tests/cross_fw/install -s \ diff --git a/tests/openvino/native/test_model_transformer.py b/tests/openvino/native/test_model_transformer.py index 84980635e8a..73a53923440 100644 --- a/tests/openvino/native/test_model_transformer.py +++ b/tests/openvino/native/test_model_transformer.py @@ -122,7 +122,8 @@ class InplaceOpTestCase: dims: str = "DEFAULT" def __str__(self) -> str: - return str(self.__dict__.values()) + s = f"{self.name}-{self.reduce_shape}-{self.op_builder.__name__}-{self.ref_types}-{self.ref_values}-{self.dims}" + return s.replace(" ", "") LINEAR_MODEL_SHAPES = { diff --git a/tests/openvino/requirements.txt b/tests/openvino/requirements.txt index f0cd9fea03b..cdb170a537a 100644 --- a/tests/openvino/requirements.txt +++ b/tests/openvino/requirements.txt @@ -1,4 +1,5 @@ pytest==8.0.2 +pytest-xdist==3.5.0 virtualenv pytest-cov pytest-mock>=3.3.1 From 057c4ce67f32f89b7b6bcdb9e34fdc09fbb68a03 Mon Sep 17 00:00:00 2001 From: Alexander Suslov Date: Wed, 24 Apr 2024 16:33:58 +0400 Subject: [PATCH 11/12] Checking model type in nncf.torch.wrap_model (#2651) ### Changes Added model type check in nncf.torch.wrap_model ### Reason for changes Improve UX ### Related tickets https://github.com/openvinotoolkit/nncf/pull/2636#discussion_r1576234452 ### Tests N/A --- nncf/torch/model_creation.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/nncf/torch/model_creation.py b/nncf/torch/model_creation.py index ae5386aa7e7..b6d21cc66a9 100644 --- a/nncf/torch/model_creation.py +++ b/nncf/torch/model_creation.py @@ -326,6 +326,11 @@ def wrap_model( :param trace_parameters: Whether to trace model parameters. Default is False. :return: A model wrapped by NNCFNetwork. """ + if not isinstance(model, torch.nn.Module): + raise TypeError( + f"The provided model type {type(model)} is incompatible. " + "Only models inheriting from torch.nn.Module are supported." + ) input_info = ExampleInputInfo.from_example_input(example_input) From d10afcf0e229fb985271feaf1b5e2e5f939b6797 Mon Sep 17 00:00:00 2001 From: Aleksei Kashapov Date: Wed, 24 Apr 2024 15:05:25 +0200 Subject: [PATCH 12/12] [PTQ] Add default batch sizes for PTQ conformance test (#2643) ### Changes Add default batch_size for calibration dataset for every model. If model has no "batch_size" parameter meaning that it doesn't support batch_size > 1 ### Reason for changes Speed up quantization ### Related tickets N/A ### Tests N/A --- tests/post_training/conftest.py | 2 +- .../data/ptq_reference_data.yaml | 126 +++++++++--------- tests/post_training/model_scope.py | 30 ++++- .../test_quantize_conformance.py | 6 +- 4 files changed, 91 insertions(+), 73 deletions(-) diff --git a/tests/post_training/conftest.py b/tests/post_training/conftest.py index 8288b993b31..0cc92c29866 100644 --- a/tests/post_training/conftest.py +++ b/tests/post_training/conftest.py @@ -19,7 +19,7 @@ def pytest_addoption(parser): parser.addoption("--data", action="store", help="Data directory") parser.addoption("--output", action="store", default="./tmp/", help="Directory to store artifacts") parser.addoption("--no-eval", action="store_true", help="Skip validation step") - parser.addoption("--batch-size", action="store", default=1, type=int, help="Batch size of calibration dataset") + parser.addoption("--batch-size", action="store", default=None, type=int, help="Batch size of calibration dataset") parser.addoption("--subset-size", type=int, default=None, help="Set subset size") parser.addoption("--fp32", action="store_true", help="Test original model") parser.addoption("--cuda", action="store_true", help="Enable CUDA_TORCH backend") diff --git a/tests/post_training/data/ptq_reference_data.yaml b/tests/post_training/data/ptq_reference_data.yaml index b2aa7826ac8..e1a1838336b 100644 --- a/tests/post_training/data/ptq_reference_data.yaml +++ b/tests/post_training/data/ptq_reference_data.yaml @@ -19,97 +19,97 @@ timm/crossvit_9_240_backend_CUDA_TORCH: timm/crossvit_9_240_backend_FP32: metric_value: 0.73982 timm/crossvit_9_240_backend_ONNX: - metric_value: 0.72854 + metric_value: 0.73484 timm/crossvit_9_240_backend_OV: - metric_value: 0.72812 + metric_value: 0.72788 timm/crossvit_9_240_backend_TORCH: - metric_value: 0.72816 + metric_value: 0.72744 timm/darknet53_backend_CUDA_TORCH: metric_value: 0.79176 timm/darknet53_backend_FP32: metric_value: 0.80006 timm/darknet53_backend_ONNX: - metric_value: 0.79336 + metric_value: 0.79176 timm/darknet53_backend_OV: - metric_value: 0.79222 + metric_value: 0.79216 timm/darknet53_backend_TORCH: - metric_value: 0.7916 + metric_value: 0.79094 timm/deit3_small_patch16_224_backend_CUDA_TORCH: metric_value: 0.76816 timm/deit3_small_patch16_224_backend_FP32: metric_value: 0.81358 timm/deit3_small_patch16_224_backend_ONNX: - metric_value: 0.81154 + metric_value: 0.81116 timm/deit3_small_patch16_224_backend_OV: metric_value: 0.81276 timm/deit3_small_patch16_224_backend_TORCH: - metric_value: 0.81278 + metric_value: 0.81274 timm/dla34_backend_CUDA_TORCH: metric_value: 0.73978 timm/dla34_backend_FP32: metric_value: 0.74628 timm/dla34_backend_ONNX: - metric_value: 0.7455 + metric_value: 0.74564 timm/dla34_backend_OV: - metric_value: 0.74556 + metric_value: 0.74532 timm/dla34_backend_TORCH: - metric_value: 0.74242 + metric_value: 0.74256 timm/dpn68_backend_CUDA_TORCH: metric_value: 0.75492 timm/dpn68_backend_FP32: metric_value: 0.76342 timm/dpn68_backend_ONNX: - metric_value: 0.7595 + metric_value: 0.75906 timm/dpn68_backend_OV: - metric_value: 0.75968 + metric_value: 0.75972 timm/dpn68_backend_TORCH: - metric_value: 0.75826 + metric_value: 0.75868 timm/efficientnet_b0_BC_backend_FP32: metric_value: 0.77698 timm/efficientnet_b0_BC_backend_ONNX: - metric_value: 0.77212 + metric_value: 0.77132 timm/efficientnet_b0_BC_backend_OV: - metric_value: 0.77218 + metric_value: 0.77166 timm/efficientnet_b0_backend_CUDA_TORCH: metric_value: 0.768 timm/efficientnet_b0_backend_FP32: metric_value: 0.77698 timm/efficientnet_b0_backend_ONNX: - metric_value: 0.77208 + metric_value: 0.7719 timm/efficientnet_b0_backend_OV: - metric_value: 0.77196 + metric_value: 0.77104 timm/efficientnet_b0_backend_TORCH: - metric_value: 0.77124 + metric_value: 0.77042 timm/efficientnet_lite0_backend_CUDA_TORCH: metric_value: 0.74686 timm/efficientnet_lite0_backend_FP32: metric_value: 0.75496 timm/efficientnet_lite0_backend_ONNX: - metric_value: 0.75214 + metric_value: 0.75184 timm/efficientnet_lite0_backend_OV: - metric_value: 0.7515 + metric_value: 0.75176 timm/efficientnet_lite0_backend_TORCH: - metric_value: 0.75236 + metric_value: 0.7517 timm/hrnet_w18_backend_CUDA_TORCH: metric_value: 0.76712 timm/hrnet_w18_backend_FP32: metric_value: 0.78124 timm/hrnet_w18_backend_ONNX: - metric_value: 0.7747 + metric_value: 0.7743 timm/hrnet_w18_backend_OV: - metric_value: 0.77526 + metric_value: 0.7743 timm/hrnet_w18_backend_TORCH: - metric_value: 0.77316 + metric_value: 0.7722 timm/inception_resnet_v2_backend_CUDA_TORCH: metric_value: 0.80024 timm/inception_resnet_v2_backend_FP32: metric_value: 0.80448 timm/inception_resnet_v2_backend_ONNX: - metric_value: 0.804 + metric_value: 0.80396 timm/inception_resnet_v2_backend_OV: metric_value: 0.80422 timm/inception_resnet_v2_backend_TORCH: - metric_value: 0.803 + metric_value: 0.80334 timm/levit_128_backend_CUDA_TORCH: metric_value: 0.7324 timm/levit_128_backend_FP32: @@ -117,120 +117,120 @@ timm/levit_128_backend_FP32: timm/levit_128_backend_ONNX: metric_value: 0.7762 timm/levit_128_backend_OV: - metric_value: 0.77696 + metric_value: 0.77644 timm/levit_128_backend_TORCH: - metric_value: 0.77752 + metric_value: 0.77814 timm/mobilenetv2_050_BC_backend_FP32: metric_value: 0.6594 timm/mobilenetv2_050_BC_backend_ONNX: - metric_value: 0.65466 + metric_value: 0.65486 timm/mobilenetv2_050_BC_backend_OV: - metric_value: 0.6543 + metric_value: 0.65332 timm/mobilenetv2_050_backend_CUDA_TORCH: metric_value: 0.64278 timm/mobilenetv2_050_backend_FP32: metric_value: 0.6594 timm/mobilenetv2_050_backend_ONNX: - metric_value: 0.65332 + metric_value: 0.6537 timm/mobilenetv2_050_backend_OV: - metric_value: 0.65282 + metric_value: 0.65314 timm/mobilenetv2_050_backend_TORCH: - metric_value: 0.65364 + metric_value: 0.65334 timm/mobilenetv3_small_050_backend_CUDA_TORCH: metric_value: 0.41888 timm/mobilenetv3_small_050_backend_FP32: metric_value: 0.57906 timm/mobilenetv3_small_050_backend_ONNX: - metric_value: 0.42104 + metric_value: 0.41828 timm/mobilenetv3_small_050_backend_OV: - metric_value: 0.42184 + metric_value: 0.41874 timm/mobilenetv3_small_050_backend_TORCH: - metric_value: 0.4291 + metric_value: 0.4267 timm/mobilenetv3_small_050_BC_backend_FP32: metric_value: 0.57906 timm/mobilenetv3_small_050_BC_backend_ONNX: - metric_value: 0.56496 + metric_value: 0.56556 timm/mobilenetv3_small_050_BC_backend_OV: - metric_value: 0.56476 + metric_value: 0.5655 timm/regnetx_002_backend_CUDA_TORCH: metric_value: 0.67452 timm/regnetx_002_backend_FP32: metric_value: 0.68756 timm/regnetx_002_backend_ONNX: - metric_value: 0.68476 + metric_value: 0.6848 timm/regnetx_002_backend_OV: - metric_value: 0.6853 + metric_value: 0.6852 timm/regnetx_002_backend_TORCH: - metric_value: 0.68492 + metric_value: 0.68576 timm/resnest14d_backend_CUDA_TORCH: metric_value: 0.74176 timm/resnest14d_backend_FP32: metric_value: 0.75516 timm/resnest14d_backend_ONNX: - metric_value: 0.74968 + metric_value: 0.75428 timm/resnest14d_backend_OV: - metric_value: 0.74984 + metric_value: 0.75 timm/resnest14d_backend_TORCH: - metric_value: 0.74838 + metric_value: 0.7485 timm/resnet18_backend_CUDA_TORCH: metric_value: 0.69748 timm/resnet18_backend_FP32: metric_value: 0.71502 timm/resnet18_backend_ONNX: - metric_value: 0.71104 + metric_value: 0.71102 timm/resnet18_backend_OV: - metric_value: 0.71042 + metric_value: 0.71116 timm/resnet18_backend_TORCH: - metric_value: 0.71024 + metric_value: 0.70982 timm/swin_base_patch4_window7_224_backend_FP32: metric_value: 0.85274 timm/swin_base_patch4_window7_224_backend_OV: - metric_value: 0.83636 + metric_value: 0.83566 timm/swin_base_patch4_window7_224_no_sq_backend_FP32: metric_value: 0.85274 timm/swin_base_patch4_window7_224_no_sq_backend_CUDA_TORCH: metric_value: 0.85142 timm/swin_base_patch4_window7_224_no_sq_backend_ONNX: - metric_value: 0.85158 + metric_value: 0.85212 timm/swin_base_patch4_window7_224_no_sq_backend_TORCH: - metric_value: 0.85142 + metric_value: 0.85178 timm/tf_inception_v3_backend_CUDA_TORCH: metric_value: 0.77542 timm/tf_inception_v3_backend_FP32: metric_value: 0.7786 timm/tf_inception_v3_backend_ONNX: - metric_value: 0.77766 + metric_value: 0.77762 timm/tf_inception_v3_backend_OV: - metric_value: 0.77742 + metric_value: 0.77748 timm/tf_inception_v3_backend_TORCH: - metric_value: 0.77642 + metric_value: 0.77586 timm/vgg11_backend_CUDA_TORCH: metric_value: 0.6809 timm/vgg11_backend_FP32: metric_value: 0.6904 timm/vgg11_backend_ONNX: - metric_value: 0.68754 + metric_value: 0.68788 timm/vgg11_backend_OV: - metric_value: 0.68732 + metric_value: 0.68788 timm/vgg11_backend_TORCH: - metric_value: 0.68754 + metric_value: 0.6879 timm/visformer_small_backend_CUDA_TORCH: metric_value: 0.77728 timm/visformer_small_backend_FP32: metric_value: 0.82098 timm/visformer_small_backend_ONNX: - metric_value: 0.81604 + metric_value: 0.81562 timm/visformer_small_backend_OV: - metric_value: 0.81692 + metric_value: 0.81674 timm/visformer_small_backend_TORCH: - metric_value: 0.81624 + metric_value: 0.8162 timm/wide_resnet50_2_backend_CUDA_TORCH: metric_value: 0.81186 timm/wide_resnet50_2_backend_FP32: metric_value: 0.81454 timm/wide_resnet50_2_backend_ONNX: - metric_value: 0.81228 + metric_value: 0.8119 timm/wide_resnet50_2_backend_OV: - metric_value: 0.8125 + metric_value: 0.81232 timm/wide_resnet50_2_backend_TORCH: - metric_value: 0.81234 + metric_value: 0.81206 diff --git a/tests/post_training/model_scope.py b/tests/post_training/model_scope.py index e6c46f715d0..0ad69a54317 100644 --- a/tests/post_training/model_scope.py +++ b/tests/post_training/model_scope.py @@ -39,7 +39,6 @@ "subset_size": 2, }, "backends": ALL_PTQ_BACKENDS + [BackendType.OPTIMUM], - "is_batch_size_supported": False, }, { "reported_name": "hf/hf-internal-testing/tiny-random-GPTNeoXForCausalLM", @@ -51,7 +50,6 @@ "subset_size": 2, }, "backends": [BackendType.OPTIMUM], - "is_batch_size_supported": False, }, # Timm models { @@ -64,6 +62,7 @@ "advanced_parameters": AdvancedQuantizationParameters(smooth_quant_alpha=-1.0), }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/darknet53", @@ -73,6 +72,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/deit3_small_patch16_224", @@ -86,6 +86,7 @@ ), }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/dla34", @@ -95,6 +96,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/dpn68", @@ -104,6 +106,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/efficientnet_b0", @@ -113,6 +116,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/efficientnet_b0_BC", @@ -123,6 +127,7 @@ "fast_bias_correction": False, }, "backends": [BackendType.ONNX, BackendType.OV], + "batch_size": 128, }, { "reported_name": "timm/efficientnet_lite0", @@ -132,6 +137,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/hrnet_w18", @@ -141,6 +147,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/inception_resnet_v2", @@ -148,6 +155,7 @@ "pipeline_cls": ImageClassificationTimm, "compression_params": {}, "backends": NNCF_PTQ_BACKENDS, + "batch_size": 64, }, { "reported_name": "timm/levit_128", @@ -161,7 +169,6 @@ ), }, "backends": NNCF_PTQ_BACKENDS, - "is_batch_size_supported": False, # Issue is raised during export with dynamich shape. }, { "reported_name": "timm/mobilenetv2_050", @@ -171,6 +178,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/mobilenetv2_050_BC", @@ -181,6 +189,7 @@ "fast_bias_correction": False, }, "backends": [BackendType.ONNX, BackendType.OV], + "batch_size": 128, }, { "reported_name": "timm/mobilenetv3_small_050", @@ -190,6 +199,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/mobilenetv3_small_050_BC", @@ -200,6 +210,7 @@ "fast_bias_correction": False, }, "backends": [BackendType.ONNX, BackendType.OV], + "batch_size": 128, }, { "reported_name": "timm/regnetx_002", @@ -209,6 +220,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/resnest14d", @@ -218,6 +230,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/resnet18", @@ -225,6 +238,7 @@ "pipeline_cls": ImageClassificationTimm, "compression_params": {}, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/swin_base_patch4_window7_224", @@ -235,6 +249,7 @@ "model_type": ModelType.TRANSFORMER, }, "backends": [BackendType.OV], + "batch_size": 32, }, { "reported_name": "timm/swin_base_patch4_window7_224_no_sq", @@ -248,6 +263,7 @@ ), }, "backends": [BackendType.TORCH, BackendType.CUDA_TORCH, BackendType.ONNX], + "batch_size": 128, }, { "reported_name": "timm/tf_inception_v3", @@ -257,6 +273,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/vgg11", @@ -264,6 +281,7 @@ "pipeline_cls": ImageClassificationTimm, "compression_params": {}, "backends": NNCF_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/visformer_small", @@ -274,6 +292,7 @@ "model_type": ModelType.TRANSFORMER, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, { "reported_name": "timm/wide_resnet50_2", @@ -283,6 +302,7 @@ "preset": QuantizationPreset.MIXED, }, "backends": ALL_PTQ_BACKENDS, + "batch_size": 128, }, ] @@ -299,7 +319,6 @@ "sensitivity_metric": SensitivityMetric.WEIGHT_QUANTIZATION_ERROR, }, "backends": [BackendType.OV], - "is_batch_size_supported": False, }, { "reported_name": "tinyllama_data_aware", @@ -307,7 +326,6 @@ "pipeline_cls": LMWeightCompression, "compression_params": {"group_size": 64, "ratio": 0.8, "mode": CompressWeightsMode.INT4_SYM}, "backends": [BackendType.OV], - "is_batch_size_supported": False, }, { "reported_name": "tinyllama_data_aware_awq", @@ -315,7 +333,6 @@ "pipeline_cls": LMWeightCompression, "compression_params": {"group_size": 64, "ratio": 0.8, "mode": CompressWeightsMode.INT4_SYM, "awq": True}, "backends": [BackendType.OV], - "is_batch_size_supported": False, }, { "reported_name": "tinyllama_data_aware_awq_stateful", @@ -324,7 +341,6 @@ "compression_params": {"group_size": 64, "ratio": 0.8, "mode": CompressWeightsMode.INT4_SYM, "awq": True}, "params": {"is_stateful": True}, "backends": [BackendType.OV], - "is_batch_size_supported": False, }, ] diff --git a/tests/post_training/test_quantize_conformance.py b/tests/post_training/test_quantize_conformance.py index 815c1f33b7b..0a42e81c70f 100644 --- a/tests/post_training/test_quantize_conformance.py +++ b/tests/post_training/test_quantize_conformance.py @@ -137,7 +137,7 @@ def maybe_skip_test_case(test_model_param, run_fp32_backend, run_torch_cuda_back pytest.skip("To run test for not quantized model use --fp32 argument") if test_model_param["backend"] == BackendType.CUDA_TORCH and not run_torch_cuda_backend: pytest.skip("To run test for CUDA_TORCH backend use --cuda argument") - if batch_size > 1 and not test_model_param["is_batch_size_supported"]: + if batch_size and batch_size > 1 and test_model_param.get("batch_size", 1) == 1: pytest.skip("The model does not support batch_size > 1. Please use --batch-size 1.") return test_model_param @@ -203,7 +203,7 @@ def test_ptq_quantization( output_dir: Path, ptq_result_data: Dict[str, RunInfo], no_eval: bool, - batch_size: int, + batch_size: Optional[int], run_fp32_backend: bool, run_torch_cuda_backend: bool, subset_size: Optional[int], @@ -222,6 +222,8 @@ def test_ptq_quantization( maybe_skip_test_case(test_model_param, run_fp32_backend, run_torch_cuda_backend, batch_size) pipeline_cls = test_model_param["pipeline_cls"] # Recalculates subset_size when subset_size is None + if batch_size is None: + batch_size = test_model_param.get("batch_size", 1) if batch_size > 1 and subset_size is None: subset_size = 300 // batch_size print(f"Update subset_size value based on provided batch_size to {subset_size}.")