diff --git a/examples/classification/configs/mixed_precision/mobilenet_v2_imagenet_mixed_int_autoq.json b/examples/classification/configs/mixed_precision/mobilenet_v2_imagenet_mixed_int_autoq.json new file mode 100644 index 00000000000..8cdf300063d --- /dev/null +++ b/examples/classification/configs/mixed_precision/mobilenet_v2_imagenet_mixed_int_autoq.json @@ -0,0 +1,50 @@ +{ + "model": "mobilenet_v2", + "pretrained": true, + "input_info": { + "sample_size": [2, 3, 224, 224] + }, + "num_classes": 1000, + "batch_size" : 128, + "epochs": 5, + "optimizer": { + "type": "Adam", + "base_lr": 0.00001, + "schedule_type": "multistep", + "steps": [ + 5 + ] + }, + "target_device": "TRIAL", + "compression": { + "algorithm": "quantization", + "weights": { + "mode": "asymmetric", + "bits": 8, + "per_channel": true + }, + "activations": { + "mode": "asymmetric", + "bits": 8, + "per_channel": false + }, + "initializer": { + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 4000 + }, + "range": + { + "type": "mean_min_max", + "num_init_samples": 1500 + }, + "precision": { + "type": "autoq", + "bits": [2, 4, 8], + "iter_number": 600, + "compression_ratio": 0.15, + "eval_subset_ratio": 0.20, + "dump_init_precision_data": true + } + } + } +} diff --git a/examples/classification/configs/mixed_precision/resnet50_imagenet_mixed_int_autoq.json b/examples/classification/configs/mixed_precision/resnet50_imagenet_mixed_int_autoq.json new file mode 100644 index 00000000000..e7949df8db9 --- /dev/null +++ b/examples/classification/configs/mixed_precision/resnet50_imagenet_mixed_int_autoq.json @@ -0,0 +1,57 @@ +{ + "model": "resnet50", + "pretrained": true, + "input_info": { + "sample_size": [ + 1, + 3, + 224, + 224 + ] + }, + "num_classes": 1000, + "batch_size" : 128, + "epochs": 30, + "optimizer": { + "base_lr": 0.00031, + "schedule_type": "plateau", + "type": "Adam", + "scheduler_params": { + "threshold": 0.1, + "cooldown": 3 + }, + "weight_decay": 1e-05 + }, + "target_device": "TRIAL", + "compression": { + "algorithm": "quantization", + "weights": { + "mode": "symmetric", + "bits": 8, + "per_channel": true + }, + "activations": { + "mode": "asymmetric", + "bits": 8, + "per_channel": false + }, + "initializer": { + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 4000 + }, + "range": + { + "type": "mean_min_max", + "num_init_samples": 1500 + }, + "precision": { + "type": "autoq", + "bits": [2, 4, 8], + "iter_number": 600, + "compression_ratio": 0.15, + "eval_subset_ratio": 0.20, + "dump_init_precision_data": true + } + } + } +} diff --git a/examples/classification/main.py b/examples/classification/main.py index 7f65ca1b6f1..60127725851 100644 --- a/examples/classification/main.py +++ b/examples/classification/main.py @@ -140,7 +140,13 @@ def main_worker(current_gpu, config: SampleConfig): train_dataset, val_dataset = create_datasets(config) train_loader, train_sampler, val_loader, init_loader = create_data_loaders(config, train_dataset, val_dataset) - nncf_config = register_default_init_args(nncf_config, init_loader, criterion, train_criterion_fn, config.device) + def autoq_eval_fn(model, eval_loader): + _, top5 = validate(eval_loader, model, criterion, config) + return top5 + + nncf_config = register_default_init_args( + nncf_config, init_loader, criterion, train_criterion_fn, + autoq_eval_fn, val_loader, config.device) # create model model = load_model(model_name, diff --git a/examples/classification/staged_quantization_worker.py b/examples/classification/staged_quantization_worker.py index de73587ee51..4f34533f375 100644 --- a/examples/classification/staged_quantization_worker.py +++ b/examples/classification/staged_quantization_worker.py @@ -133,7 +133,14 @@ def staged_quantization_main_worker(current_gpu, config): # Data loading code train_dataset, val_dataset = create_datasets(config) train_loader, train_sampler, val_loader, init_loader = create_data_loaders(config, train_dataset, val_dataset) - nncf_config = register_default_init_args(nncf_config, init_loader, criterion, train_criterion_fn, config.device) + + def autoq_eval_fn(model, eval_loader): + _, top5 = validate(eval_loader, model, criterion, config) + return top5 + + nncf_config = register_default_init_args( + nncf_config, init_loader, criterion, train_criterion_fn, + autoq_eval_fn, val_loader, config.device) # create model model_name = config['model'] diff --git a/examples/common/utils.py b/examples/common/utils.py index 8e830bda1c3..f16dbd45391 100644 --- a/examples/common/utils.py +++ b/examples/common/utils.py @@ -33,6 +33,7 @@ from torch.utils.tensorboard import SummaryWriter from texttable import Texttable import mlflow +import torch from examples.common.example_logger import logger as default_logger from nncf.utils import is_main_process @@ -150,6 +151,9 @@ def configure_device(current_gpu, config: SampleConfig): config.device = get_device(config) + if config.execution_mode == ExecutionMode.SINGLE_GPU: + torch.cuda.set_device(config.current_gpu) + def configure_logging(sample_logger, config): config.tb = SummaryWriter(config.log_dir) diff --git a/examples/object_detection/main.py b/examples/object_detection/main.py index af70082551c..3fe61773ff2 100644 --- a/examples/object_detection/main.py +++ b/examples/object_detection/main.py @@ -140,7 +140,14 @@ def criterion_fn(model_outputs, target, criterion): loss_l, loss_c = criterion(model_outputs, target) return loss_l + loss_c - nncf_config = register_default_init_args(nncf_config, init_data_loader, criterion, criterion_fn, config.device) + def autoq_test_fn(model, eval_loader): + # RL is maximization, change the loss polarity + return -1 * test_net(model, config.device, eval_loader, distributed=config.distributed, + loss_inference=True, criterion=criterion) + + nncf_config = register_default_init_args( + nncf_config, init_data_loader, criterion, criterion_fn, + autoq_test_fn, test_data_loader, config.device) ################## # Prepare model diff --git a/examples/semantic_segmentation/main.py b/examples/semantic_segmentation/main.py index e43af555255..12b47372fa7 100644 --- a/examples/semantic_segmentation/main.py +++ b/examples/semantic_segmentation/main.py @@ -50,7 +50,7 @@ from nncf.utils import is_main_process -def get_arguments(args): +def get_arguments_parser(): parser = get_common_argument_parser() parser.add_argument( "--dataset", @@ -58,7 +58,7 @@ def get_arguments(args): choices=["camvid", "cityscapes", "mapillary"], default=None ) - return parser.parse_args(args=args) + return parser def get_preprocessing_transforms(config): @@ -436,6 +436,7 @@ def test(model, test_loader, criterion, class_encoding, config): gt_labels = center_crop(gt_labels, outputs_size_hw).contiguous() data_utils.show_ground_truth_vs_prediction(images, gt_labels, color_predictions, class_encoding) + return miou def predict(model, images, class_encoding, config): images = images.to(config.device) @@ -489,7 +490,13 @@ def criterion_fn(model_outputs, target, criterion_): loaders, w_class = load_dataset(dataset, config) train_loader, val_loader, init_loader = loaders criterion = get_criterion(w_class, config) - nncf_config = register_default_init_args(nncf_config, init_loader, criterion, criterion_fn, config.device) + + def autoq_test_fn(model, eval_loader): + return test(model, eval_loader, criterion, color_encoding, config) + + nncf_config = register_default_init_args( + nncf_config, init_loader, criterion, criterion_fn, + autoq_test_fn, val_loader, config.device) model = load_model(config.model, pretrained=pretrained, @@ -537,7 +544,7 @@ def criterion_fn(model_outputs, target, criterion_): def main(argv): - parser = get_common_argument_parser() + parser = get_arguments_parser() arguments = parser.parse_args(args=argv) config = create_sample_config(arguments, parser) if arguments.dist_url == "env://": diff --git a/licensing/third-party-programs.txt b/licensing/third-party-programs.txt new file mode 100644 index 00000000000..1b75c920943 --- /dev/null +++ b/licensing/third-party-programs.txt @@ -0,0 +1,302 @@ +NNCF Third Party Programs File + +This file contains the list of third party software ("third party programs") +contained in the Intel software and their required notices and/or license +terms. This third party software, even if included with the distribution of +the Intel software, may be governed by separate license terms, including +without limitation, third party license terms, other Intel software license +terms, and open source software license terms. These separate license terms +govern your use of the third party programs as set forth in the +"third-party-programs.txt" or other similarly-named text file. + +Third party programs and their corresponding required notices and/or license +terms are listed below. + +------------------------------------------------------------- + +1. scikit-learn: machine learning in Python +Copyright (c) 2007-2020 The scikit-learn developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +------------------------------------------------------------- + +2. natsort: Simple yet flexible natural sorting in Python. + Copyright (c) 2012-2020 Seth M. Morton + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +------------------------------------------------------------- + +3. HAQ: Hardware-Aware Automated Quantization with Mixed Precision + Copyright [2019] [MIT HAN Lab] + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2019] [MIT HAN Lab] + + 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. + +------------------------------------------------------------- + +4. keras-rl: Deep Reinforcement Learning for Keras + Copyright (c) 2016 Matthias Plappert + +The MIT License (MIT) + +Copyright (c) 2016 Matthias Plappert + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/nncf/automl/agent/ddpg/ddpg.py b/nncf/automl/agent/ddpg/ddpg.py new file mode 100644 index 00000000000..cdf63800327 --- /dev/null +++ b/nncf/automl/agent/ddpg/ddpg.py @@ -0,0 +1,339 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +# Modification Notes: +# This implementation is modified from +# 1. https://github.com/mit-han-lab/haq/blob/master/lib/rl/ddpg.py +# 2. https://github.com/mit-han-lab/haq/blob/master/lib/utils/utils.py + + +import numpy as np + +import torch +import torch.nn as nn +from torch.autograd import Variable +from torch.optim import Adam +from types import SimpleNamespace + +from nncf.automl.agent.ddpg.memory import SequentialMemory + + +criterion = nn.MSELoss() +USE_CUDA = torch.cuda.is_available() +FLOAT = torch.cuda.FloatTensor if USE_CUDA else torch.FloatTensor + + +def to_numpy(var): + return var.cpu().data.numpy() if USE_CUDA else var.data.numpy() + + +def to_tensor(ndarray, volatile=False, requires_grad=False, dtype=FLOAT): + return Variable( + torch.from_numpy(ndarray), volatile=volatile, requires_grad=requires_grad + ).type(dtype) + + +def sample_from_truncated_normal_distribution(lower, upper, mu, sigma, size=1): + from scipy import stats + return stats.truncnorm.rvs((lower-mu)/sigma, (upper-mu)/sigma, loc=mu, scale=sigma, size=size) + + +class Actor(nn.Module): + def __init__(self, nb_states, nb_actions, hidden1=400, hidden2=300, init_w=3e-3): + super().__init__() + self.fc1 = nn.Linear(nb_states, hidden1) + self.fc2 = nn.Linear(hidden1, hidden2) + self.fc3 = nn.Linear(hidden2, nb_actions) + self.relu = nn.ReLU() + self.sigmoid = nn.Sigmoid() + + def forward(self, x): + out = self.fc1(x) + out = self.relu(out) + out = self.fc2(out) + out = self.relu(out) + out = self.fc3(out) + out = self.sigmoid(out) + return out + + +class Critic(nn.Module): + def __init__(self, nb_states, nb_actions, hidden1=400, hidden2=300, init_w=3e-3): + super().__init__() + self.fc11 = nn.Linear(nb_states, hidden1) + self.fc12 = nn.Linear(nb_actions, hidden1) + self.fc2 = nn.Linear(hidden1, hidden2) + self.fc3 = nn.Linear(hidden2, 1) + self.relu = nn.ReLU() + + def forward(self, xs): + x, a = xs + out = self.fc11(x) + self.fc12(a) + out = self.relu(out) + out = self.fc2(out) + out = self.relu(out) + out = self.fc3(out) + return out + + +class DDPG: + LBOUND = 0.0 + RBOUND = 1.0 + def __init__(self, nb_states, nb_actions, hparam_override: dict = None): + self.nb_states = nb_states + self.nb_actions = nb_actions + + hyperparameters = { + "seed": 528, + "train_episode": 600, + "delta_decay": 0.995, + "hidden1": 300, + "hidden2": 300, + "init_w": 0.003, + "lr_c": 0.001, + "lr_a": 0.0001, + "rmsize": 2048, + "window_length": 1, + "bsize": 64, + "tau": 0.01, + "discount": 1.0, + "epsilon": 50000, + "init_delta": 0.5, + "warmup_iter_number": 20, + "n_update": 1 + } + + if hparam_override is not None: + for hparam, hparam_val in hparam_override.items(): + if hparam in hyperparameters: + hyperparameters[hparam] = hparam_val + if 'iter_number' in hparam_override: + hyperparameters['train_episode'] = hparam_override['iter_number'] + + args = SimpleNamespace(**hyperparameters) + + if args.seed is None: + self.seed(0) + else: + self.seed(args.seed) + + # Create Actor and Critic Network + net_cfg = { + 'hidden1': args.hidden1, + 'hidden2': args.hidden2, + 'init_w': args.init_w + } + + self.actor = Actor(self.nb_states, self.nb_actions, **net_cfg) + self.actor_target = Actor(self.nb_states, self.nb_actions, **net_cfg) + self.actor_optim = Adam(self.actor.parameters(), lr=args.lr_a) + + self.critic = Critic(self.nb_states, self.nb_actions, **net_cfg) + self.critic_target = Critic(self.nb_states, self.nb_actions, **net_cfg) + self.critic_optim = Adam(self.critic.parameters(), lr=args.lr_c) + + self.hard_update(self.actor_target, self.actor) # Make sure target is with the same weight + self.hard_update(self.critic_target, self.critic) + + # Create replay buffer + self.memory = SequentialMemory(limit=args.rmsize, window_length=args.window_length) + + # Hyper-parameters + self.n_update = args.n_update + self.batch_size = args.bsize + self.tau = args.tau + self.discount = args.discount + self.depsilon = 1.0 / args.epsilon + + # noise + self.init_delta = args.init_delta + self.delta_decay = args.delta_decay + self.update_delta_decay_factor(args.train_episode) + self.warmup_iter_number = args.warmup_iter_number + self.delta = args.init_delta + + # loss + self.value_loss = 0.0 + self.policy_loss = 0.0 + + self.epsilon = 1.0 + self.is_training = True + + if USE_CUDA: + self.cuda() + + # moving average baseline + self.moving_average = None + self.moving_alpha = 0.5 # based on batch, so small + + + def update_delta_decay_factor(self, num_train_episode): + assert num_train_episode > 0, "Number of train episode must be larger than 0" + + if num_train_episode < 1000: + # every hundred of episode below 1000 (100, 200 ... 1000) + calibrated_factor = [0.960, 0.960, 0.980, 0.987, 0.992, + 0.993, 0.995, 0.995, 0.996, 0.996] + self.delta_decay = calibrated_factor[num_train_episode//100] + + elif num_train_episode <= 3000: + self.delta_decay = (num_train_episode-999)*(0.999-0.997)/(3000-999) + 0.997 + + else: + self.delta_decay = 0.999 + + + def update_policy(self): + # Sample batch + state_batch, action_batch, reward_batch, \ + next_state_batch, terminal_batch = self.memory.sample_and_split(self.batch_size) + + # normalize the reward + batch_mean_reward = np.mean(reward_batch) + if self.moving_average is None: + self.moving_average = batch_mean_reward + else: + self.moving_average += self.moving_alpha * (batch_mean_reward - self.moving_average) + reward_batch -= self.moving_average + + # Prepare for the target q batch + with torch.no_grad(): + next_q_values = self.critic_target([ + to_tensor(next_state_batch), + self.actor_target(to_tensor(next_state_batch)), + ]) + + target_q_batch = to_tensor(reward_batch) + \ + self.discount * to_tensor(terminal_batch.astype(np.float)) * next_q_values + + # Critic update + self.critic.zero_grad() + + q_batch = self.critic([to_tensor(state_batch), to_tensor(action_batch)]) + + value_loss = criterion(q_batch, target_q_batch) + value_loss.backward() + self.critic_optim.step() + + # Actor update + self.actor.zero_grad() + + policy_loss = -self.critic([ + to_tensor(state_batch), + self.actor(to_tensor(state_batch)) + ]) + + policy_loss = policy_loss.mean() + policy_loss.backward() + self.actor_optim.step() + + # Target update + self.soft_update(self.actor_target, self.actor) + self.soft_update(self.critic_target, self.critic) + + # update for log + self.value_loss = value_loss + self.policy_loss = policy_loss + + + def eval(self): + self.actor.eval() + self.actor_target.eval() + self.critic.eval() + self.critic_target.eval() + + + def cuda(self): + self.actor.cuda() + self.actor_target.cuda() + self.critic.cuda() + self.critic_target.cuda() + + + def observe(self, r_t, s_t, a_t, done): + if self.is_training: + self.memory.append(s_t, a_t, r_t, done) # save to memory + + + def random_action(self): + action = np.random.uniform(self.LBOUND, self.RBOUND, self.nb_actions) + return action + + + def select_action(self, s_t, episode, decay_epsilon=True): + action = to_numpy(self.actor(to_tensor(np.array(s_t).reshape(1, -1)))).squeeze(0) + + if decay_epsilon is True: + self.delta = self.init_delta * (self.delta_decay ** (episode - self.warmup_iter_number)) + action = sample_from_truncated_normal_distribution( + lower=self.LBOUND, upper=self.RBOUND, mu=action, sigma=self.delta, size=self.nb_actions) + + return np.clip(action, self.LBOUND, self.RBOUND) + + + def reset(self, obs): + pass + + + def load_weights(self, output): + if output is None: + return + + self.actor.load_state_dict( + torch.load('{}/actor.pkl'.format(output)) + ) + + self.critic.load_state_dict( + torch.load('{}/critic.pkl'.format(output)) + ) + + + def save_model(self, output): + torch.save( + self.actor.state_dict(), + '{}/actor.pkl'.format(output) + ) + torch.save( + self.critic.state_dict(), + '{}/critic.pkl'.format(output) + ) + + + def seed(self, s): + torch.manual_seed(s) + if USE_CUDA: + torch.cuda.manual_seed(s) + + + def soft_update(self, target, source): + for target_param, param in zip(target.parameters(), source.parameters()): + target_param.data.copy_( + target_param.data * (1.0 - self.tau) + param.data * self.tau + ) + + + def hard_update(self, target, source): + for target_param, param in zip(target.parameters(), source.parameters()): + target_param.data.copy_(param.data) + + + def get_delta(self): + return self.delta + + + def get_value_loss(self): + return self.value_loss + + + def get_policy_loss(self): + return self.policy_loss diff --git a/nncf/automl/agent/ddpg/memory.py b/nncf/automl/agent/ddpg/memory.py new file mode 100644 index 00000000000..05b47f62eb7 --- /dev/null +++ b/nncf/automl/agent/ddpg/memory.py @@ -0,0 +1,244 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +# Modification Notes: +# This implementation is modified from +# https://github.com/mit-han-lab/haq/blob/master/lib/rl/memory.py + + +from __future__ import absolute_import +from collections import deque, namedtuple +import warnings +import random + +import numpy as np + +# [reference] https://github.com/matthiasplappert/keras-rl/blob/master/rl/memory.py + +# This is to be understood as a transition: Given `state0`, performing `action` +# yields `reward` and results in `state1`, which might be `terminal`. +Experience = namedtuple('Experience', 'state0, action, reward, state1, terminal1') + + +def sample_batch_indexes(low, high, size): + if high - low >= size: + # We have enough data. Draw without replacement, that is each index is unique in the + # batch. We cannot use `np.random.choice` here because it is horribly inefficient as + # the memory grows. See https://github.com/numpy/numpy/issues/2764 for a discussion. + # `random.sample` does the same thing (drawing without replacement) and is way faster. + # try: + # r = xrange(low, high) + # except NameError: + r = range(low, high) + batch_idxs = random.sample(r, size) + else: + # Not enough data. Help ourselves with sampling from the range, but the same index + # can occur multiple times. This is not good and should be avoided by picking a + # large enough warm-up phase. + warnings.warn( + 'Not enough entries to sample without replacement.' + 'Consider increasing your warm-up phase to avoid oversampling!') + batch_idxs = np.random.random_integers(low, high - 1, size=size) + assert len(batch_idxs) == size + return batch_idxs + + +class RingBuffer: + def __init__(self, maxlen): + self.maxlen = maxlen + self.start = 0 + self.length = 0 + self.data = [None for _ in range(maxlen)] + + def __len__(self): + return self.length + + def __getitem__(self, idx): + if idx < 0 or idx >= self.length: + raise KeyError() + return self.data[(self.start + idx) % self.maxlen] + + def append(self, v): + if self.length < self.maxlen: + # We have space, simply increase the length. + self.length += 1 + elif self.length == self.maxlen: + # No space, "remove" the first item. + self.start = (self.start + 1) % self.maxlen + else: + # This should never happen. + raise RuntimeError() + self.data[(self.start + self.length - 1) % self.maxlen] = v + + +def zeroed_observation(observation): + if hasattr(observation, 'shape'): + return np.zeros(observation.shape) + if hasattr(observation, '__iter__'): + out = [] + for x in observation: + out.append(zeroed_observation(x)) + return out + return 0. + + +class Memory: + def __init__(self, window_length, ignore_episode_boundaries=False): + self.window_length = window_length + self.ignore_episode_boundaries = ignore_episode_boundaries + + self.recent_observations = deque(maxlen=window_length) + self.recent_terminals = deque(maxlen=window_length) + + def sample(self, batch_size, batch_idxs=None): + raise NotImplementedError() + + def append(self, observation, action, reward, terminal, training=True): + self.recent_observations.append(observation) + self.recent_terminals.append(terminal) + + def get_recent_state(self, current_observation): + # This code is slightly complicated by the fact that subsequent observations might be + # from different episodes. We ensure that an experience never spans multiple episodes. + # This is probably not that important in practice but it seems cleaner. + state = [current_observation] + idx = len(self.recent_observations) - 1 + for offset in range(0, self.window_length - 1): + current_idx = idx - offset + current_terminal = self.recent_terminals[current_idx - 1] if current_idx - 1 >= 0 else False + if current_idx < 0 or (not self.ignore_episode_boundaries and current_terminal): + # The previously handled observation was terminal, don't add the current one. + # Otherwise we would leak into a different episode. + break + state.insert(0, self.recent_observations[current_idx]) + while len(state) < self.window_length: + state.insert(0, zeroed_observation(state[0])) + return state + + def get_config(self): + config = { + 'window_length': self.window_length, + 'ignore_episode_boundaries': self.ignore_episode_boundaries, + } + return config + + +class SequentialMemory(Memory): + def __init__(self, limit, **kwargs): + super().__init__(**kwargs) + + self.limit = limit + + # Do not use deque to implement the memory. This data structure may seem convenient but + # it is way too slow on random access. Instead, we use our own ring buffer implementation. + self.actions = RingBuffer(limit) + self.rewards = RingBuffer(limit) + self.terminals = RingBuffer(limit) + self.observations = RingBuffer(limit) + + def sample(self, batch_size, batch_idxs=None): + if batch_idxs is None: + # Draw random indexes such that we have at least a single entry before each + # index. + batch_idxs = sample_batch_indexes(0, self.nb_entries - 1, size=batch_size) + batch_idxs = np.array(batch_idxs) + 1 + assert np.min(batch_idxs) >= 1 + assert np.max(batch_idxs) < self.nb_entries + assert len(batch_idxs) == batch_size + + # Create experiences + experiences = [] + for idx in batch_idxs: + terminal0 = self.terminals[idx - 2] if idx >= 2 else False + while terminal0: + # Skip this transition because the environment was reset here. Select a new, random + # transition and use this instead. This may cause the batch to contain the same + # transition twice. + idx = sample_batch_indexes(1, self.nb_entries, size=1)[0] + terminal0 = self.terminals[idx - 2] if idx >= 2 else False + assert 1 <= idx < self.nb_entries + + # This code is slightly complicated by the fact that subsequent observations might be + # from different episodes. We ensure that an experience never spans multiple episodes. + # This is probably not that important in practice but it seems cleaner. + state0 = [self.observations[idx - 1]] + for offset in range(0, self.window_length - 1): + current_idx = idx - 2 - offset + current_terminal = self.terminals[current_idx - 1] if current_idx - 1 > 0 else False + if current_idx < 0 or (not self.ignore_episode_boundaries and current_terminal): + # The previously handled observation was terminal, don't add the current one. + # Otherwise we would leak into a different episode. + break + state0.insert(0, self.observations[current_idx]) + while len(state0) < self.window_length: + state0.insert(0, zeroed_observation(state0[0])) + action = self.actions[idx - 1] + reward = self.rewards[idx - 1] + terminal1 = self.terminals[idx - 1] + + # Okay, now we need to create the follow-up state. This is state0 shifted on timestep + # to the right. Again, we need to be careful to not include an observation from the next + # episode if the last state is terminal. + state1 = [np.copy(x) for x in state0[1:]] + state1.append(self.observations[idx]) + + assert len(state0) == self.window_length + assert len(state1) == len(state0) + experiences.append(Experience(state0=state0, action=action, reward=reward, + state1=state1, terminal1=terminal1)) + assert len(experiences) == batch_size + return experiences + + def sample_and_split(self, batch_size, batch_idxs=None): + experiences = self.sample(batch_size, batch_idxs) + + state0_batch = [] + reward_batch = [] + action_batch = [] + terminal1_batch = [] + state1_batch = [] + for e in experiences: + state0_batch.append(e.state0) + state1_batch.append(e.state1) + reward_batch.append(e.reward) + action_batch.append(e.action) + terminal1_batch.append(0. if e.terminal1 else 1.) + + # Prepare and validate parameters. + state0_batch = np.array(state0_batch, 'double').reshape(batch_size, -1) + state1_batch = np.array(state1_batch, 'double').reshape(batch_size, -1) + terminal1_batch = np.array(terminal1_batch, 'double').reshape(batch_size, -1) + reward_batch = np.array(reward_batch, 'double').reshape(batch_size, -1) + action_batch = np.array(action_batch, 'double').reshape(batch_size, -1) + + return state0_batch, action_batch, reward_batch, state1_batch, terminal1_batch + + def append(self, observation, action, reward, terminal, training=True): + super().append(observation, action, reward, terminal, training=training) + + # This needs to be understood as follows: in `observation`, take `action`, obtain `reward` + # and weather the next state is `terminal` or not. + if training: + self.observations.append(observation) + self.actions.append(action) + self.rewards.append(reward) + self.terminals.append(terminal) + + @property + def nb_entries(self): + return len(self.observations) + + def get_config(self): + config = super().get_config() + config['limit'] = self.limit + return config diff --git a/nncf/automl/environment/quantization_env.py b/nncf/automl/environment/quantization_env.py new file mode 100644 index 00000000000..53d11159695 --- /dev/null +++ b/nncf/automl/environment/quantization_env.py @@ -0,0 +1,568 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import logging + +import os.path as osp +from pathlib import Path +from typing import List, Dict, Union, Tuple, Callable + +import torch +import torch.nn as nn +import torch.nn.parallel +import torch.optim +import torch.utils.data +import torch.utils.data.distributed + +import ctypes +import json +import numpy as np +import pandas as pd +from copy import deepcopy +from collections import OrderedDict +from natsort import natsorted + +from nncf import NNCFConfig +from nncf.debug import is_debug, DEBUG_LOG_DIR +from nncf.nncf_logger import logger +from nncf.hw_config import HWConfigType +from nncf.initialization import PartialDataLoader +from nncf.quantization.layers import BaseQuantizer +from nncf.quantization.algo import QuantizationController, NNCFNetwork +from nncf.quantization.precision_init.adjacent_quantizers import GroupsOfAdjacentQuantizers +from nncf.quantization.quantizer_id import QuantizerId, WeightQuantizerId, \ + NonWeightQuantizerId, InputQuantizerId, FunctionQuantizerId + +from sklearn.preprocessing import MinMaxScaler + +def find_qid_by_str(qctrl: QuantizationController, qid_str: str) -> QuantizerId: + for _qid, _q in qctrl.all_quantizations.items(): + if qid_str == str(_qid): + return _qid + return None + +class ModelSizeCalculator: + FLOAT_BITWIDTH = ctypes.sizeof(ctypes.c_float) * 8 + def __init__(self, qmodel: NNCFNetwork, per_quantizer_bw_space: Dict[QuantizerId, List[int]]): + self._bw_space_map = OrderedDict() + self._nparam_map = OrderedDict() + for qid, bw_space in per_quantizer_bw_space.items(): + if isinstance(qid, WeightQuantizerId): + self._bw_space_map[qid] = bw_space + m = qmodel.get_module_by_scope(qid.scope) + self._nparam_map[qid] = np.prod(m.weight.size()) + + self.min_model_size, self.max_model_size = \ + self._calc_min_max_model_size() + + self.fp_model_size = self.get_uniform_bit_model_size(ModelSizeCalculator.FLOAT_BITWIDTH) + + def __call__(self, per_quantizer_bw): + return self.get_model_size(per_quantizer_bw) + + def _calc_min_max_model_size(self) -> Tuple[np.int64, np.int64]: + nparam_array = np.array(list(self._nparam_map.values())) + min_size = np.sum(nparam_array * np.array(list(map(min, self._bw_space_map.values())))) + max_size = np.sum(nparam_array * np.array(list(map(max, self._bw_space_map.values())))) + return min_size, max_size + + def get_uniform_bit_model_size(self, uniform_bitwidth: int) -> np.int64: + return np.sum(np.array(list(self._nparam_map.values())*uniform_bitwidth)) + + def get_model_size(self, per_quantizer_bw: Dict[QuantizerId, int]) -> np.int64: + model_size = 0 + for qid, nparam in self._nparam_map.items(): + if qid in per_quantizer_bw: + model_size += nparam * per_quantizer_bw[qid] + else: + logger.warning("[ModelSizeCalculator] Missing Bitwidth of QID: {}, using {} bits" + .format(str(qid), ModelSizeCalculator.FLOAT_BITWIDTH)) + model_size += nparam * ModelSizeCalculator.FLOAT_BITWIDTH + return model_size + + def get_model_size_ratio(self, per_quantizer_bw: Dict[QuantizerId, int]) -> np.float64: + return self.get_model_size(per_quantizer_bw)/self.fp_model_size + + +class QuantizationEnv: + # pylint:disable=too-many-branches,too-many-statements + def __init__(self, + quantization_controller: QuantizationController, + eval_loader: torch.utils.data.DataLoader, + eval_fn: Callable[[nn.Module, torch.utils.data.DataLoader], float], + config: NNCFConfig): + + logger.info("[Q.Env] Instantiating NNCF Quantization Environment") + self.qctrl = quantization_controller + self.qmodel = quantization_controller._model + self.eval_loader = eval_loader + self.eval_fn = eval_fn + self.config = config + + # Extract model name for labelling + self.model_name = self.config.get('model', None) + if self.model_name is None: + self.model_name = self.qmodel.nncf_module.__class__.__name__ + + # Check and only proceed if target device is supported by Q.Env + self.hw_cfg_type = self.qctrl.quantization_config.get("hw_config_type") + if self.hw_cfg_type is not None and self.hw_cfg_type is not HWConfigType.VPU: + raise ValueError("Unsupported device ({}). Automatic Precision Initialization only supports for " + "target_device NONE or VPU".format(self.hw_cfg_type.value)) + + # Extract Precision Initialization Config + # TODO: Clean up + if self.config.get('compression', {}).get('initializer', {}).get('precision', {}).get('type', {}) == 'autoq': + self.autoq_cfg = self.config.get('compression', {}).get('initializer', {}).get('precision') + else: + raise ValueError("Missing/Invalid Config of Precision Initializer. " + "Pls review config['compression']['initializer']['precision']") + + # Set target compression ratio + self.compression_ratio = self.autoq_cfg.get('compression_ratio', 0.15) + + self.eval_loader = PartialDataLoader(self.eval_loader, iter_ratio=self.autoq_cfg.get('eval_subset_ratio', 1.0)) + + # Bool to disable hard resource constraint + self.skip_constraint = False + if 'skip_constraint' in self.autoq_cfg: + self.skip_constraint = self.autoq_cfg['skip_constraint'] + + # Bool to enable fine-tuning in each episode. Placeholder for now + self.finetune = False + if 'finetune' in self.autoq_cfg: + self.finetune = self.autoq_cfg['finetune'] + + # Configure search space for precision according to target device + if self.hw_cfg_type is None: + self.model_bitwidth_space = self.autoq_cfg.get('bits', [2, 4, 8]) + elif self.hw_cfg_type is HWConfigType.VPU: + self.model_bitwidth_space = self.qctrl._hw_precision_constraints.get_all_unique_bits() + self.model_bitwidth_space = sorted(list(self.model_bitwidth_space)) + + # Create mapping of QuantizerId to its bitwidth space (per quantizer bitwidth space) + self.bw_space_map = OrderedDict.fromkeys(self.qctrl.all_quantizations.keys()) + if self.hw_cfg_type is None: + for qid in self.bw_space_map.keys(): + self.bw_space_map[qid] = self.model_bitwidth_space + else: + assert hasattr(self.qctrl._hw_precision_constraints, '_constraints'), \ + "feasible bitwidth per quantizer not found" + for qid, bw_space in self.qctrl._hw_precision_constraints._constraints.items(): + self.bw_space_map[qid] = sorted(list(bw_space)) + + # Quantizer Master Table Creation + self._groups_of_adjacent_quantizers = GroupsOfAdjacentQuantizers(self.qctrl) + self.quantizer_table = self._create_quantizer_table() + + # Create master dataframe to keep track of quantizable layers and thier attributes + self.master_df, self.state_list = self._get_state_space(self.qctrl, self.qmodel, self.quantizer_table) + if self.master_df.isnull().values.any(): + raise ValueError("Q.Env Master Dataframe has null value(s)") + + assert len(self.quantizer_table) == len(self.qctrl.all_quantizations), \ + "Number of Quantizer is not tally between quantizer table and quantization controller" + + # MinMaxScaler for State Embedding + self.state_scaler = MinMaxScaler() + self.state_scaler.fit(self.master_df[self.state_list]) + + # Model Size Calculation + self.model_size_calculator = ModelSizeCalculator(self.qmodel, self.bw_space_map) + self.orig_model_size = self.model_size_calculator.fp_model_size + self.min_model_size = self.model_size_calculator.min_model_size + self.max_model_size = self.model_size_calculator.max_model_size + self.target_model_size = self.orig_model_size*self.compression_ratio + + if self.target_model_size < self.min_model_size and self.target_model_size > self.max_model_size: + raise ValueError("Model Size Ratio {} is out of bound ({}, {})" + .format(self.compression_ratio, + self.min_model_size/self.orig_model_size, + self.max_model_size/self.orig_model_size)) + + # Evaluate and store metric score of pretrained model + self._evaluate_pretrained_model() + self.qmodel_init_sd = deepcopy(self.qmodel.state_dict()) + + self.reset() + + self._dump_autoq_data = self.autoq_cfg.get('dump_init_precision_data', False) + if self._dump_autoq_data or is_debug(): + dump_dir = self.config.get('log_dir', None) + if dump_dir is None: + dump_dir = DEBUG_LOG_DIR + self.dump_dir = Path(dump_dir) / Path("autoq_env_dump") + self.dump_dir.mkdir(parents=True, exist_ok=True) + # Serialize Q.Env information. Note that these functions should be at the end of Q.Env Initialization. + self._dump_master_df() + self._dump_quantized_graph() + self._dump_groups_of_adjacent_quantizers() + + # End of QuantizationEnv.__init__() + # -------------------------------------------------------------------------------------------------------------- + + + def reset(self): + self.collected_strategy = [] + self.master_df['action'] = max(self.model_bitwidth_space) + self.master_df['prev_action'] = 0 + self.master_df['unconstrained_action'] = 0 + + + def _create_quantizer_table(self) -> pd.DataFrame: + # Create a mapping of qid to its adjacent quantizer group id + adjq_gid_map = OrderedDict.fromkeys(self.qctrl.all_quantizations.keys()) + for qid, qmod in self.qctrl.all_quantizations.items(): + adjq_gid_map[qid] = self._groups_of_adjacent_quantizers.get_group_id_for_quantizer(qmod) + + assert len(set(self.bw_space_map.keys()) - set(adjq_gid_map.keys())) == 0, \ + "both bw_space_map and adjq_gid_map must have exact keys." + + # Create a mapping of qid to its nodekey in NNCFGraph + qid_nodekey_map = self._generate_qid_nodekey_map(self.qctrl, self.qmodel) + + assert len(set(qid_nodekey_map.keys()) - set(adjq_gid_map.keys())) == 0, \ + "both qid_nodekey_map and adjq_gid_map must have exact keys." + + d = OrderedDict() + for qid, qmod in self.qctrl.all_quantizations.items(): + nodekey = qid_nodekey_map[qid] + q_nx_nodeid = nodekey.split()[0] + idx_str = '-'.join([q_nx_nodeid, str(qid)]) + gid = adjq_gid_map[qid] + + d[idx_str] = OrderedDict() + d[idx_str]['qid'] = str(qid) + d[idx_str]['q_nx_nodeid'] = q_nx_nodeid + d[idx_str]['q_nx_nodekey'] = nodekey + d[idx_str]['gid'] = gid + d[idx_str]['bw_space'] = self.bw_space_map[qid] + + if isinstance(qid, WeightQuantizerId): + d[idx_str]['state_scope'] = qid.scope + elif isinstance(qid, NonWeightQuantizerId): + d[idx_str]['state_scope'] = qid.ia_op_exec_context.scope_in_model + else: + raise NotImplementedError("QuantizerId: {} of {} class is not supported." + .format(str(qid), str(qid.__class__.__name__))) + + # quantizer_table index is QuantizerId in string prepended with its quantize node id in NNCFGraph + df = pd.DataFrame.from_dict(d, orient='index') + df['qid_obj'] = df['qid'].apply(lambda x: find_qid_by_str(self.qctrl, x)) + df['qmodule'] = df['qid_obj'].apply(lambda x: self.qctrl.all_quantizations[x]) + df['is_wt_quantizer'] = df['qmodule'].apply(lambda x: x.is_weights) + df['state_module'] = df['state_scope'].apply(self.qmodel.get_module_by_scope) + + quantizer_table = df.loc[natsorted(df.index)] + return quantizer_table + + + def _get_state_space(self, + quantization_controller: QuantizationController, + quantized_model: NNCFNetwork, + quantizer_table: pd.DataFrame) -> Tuple[pd.DataFrame, List[str]]: + def annotate_learnable_module_io_shape(model): + def annotate_io_shape(module, input_, output): + if hasattr(module, 'weight') or isinstance(module, BaseQuantizer): + module.input_shape_ = input_[0].shape + module.output_shape_ = output.shape + + hook_list = [m.register_forward_hook(annotate_io_shape) for n, m in model.named_modules()] + model.do_dummy_forward(force_eval=True) + for h in hook_list: + h.remove() + + annotate_learnable_module_io_shape(quantized_model) + + # State Embedding Extraction + #--------------------------- + df = quantizer_table + layer_attr_df = df.apply(self._get_layer_attr, axis=1) + layer_attr_df['layer_idx'] = np.array(range(len(layer_attr_df))) + layer_attr_df['weight_quantizer'] = df['is_wt_quantizer'].astype('float') + state_list = layer_attr_df.columns.to_list() + + # create master dataframe + master_df = pd.concat([df, layer_attr_df], axis='columns') + + # Annotate a min and a max value in prev_action before minmaxscaler fitting + master_df.loc[master_df.index[0], 'prev_action'] = max(self.model_bitwidth_space) + master_df.loc[master_df.index[-1], 'prev_action'] = min(self.model_bitwidth_space) + + return master_df, state_list + + + def _get_layer_attr(self, row: pd.Series) -> pd.Series: + m = row.state_module + qid = row.qid_obj + feature = OrderedDict() + + if isinstance(qid, WeightQuantizerId): + if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)): + feature['conv_dw'] = int(m.weight.shape[1] == m.groups) # 1.0 for depthwise, 0.0 for other conv2d + feature['cin'] = m.weight.shape[1] + feature['cout'] = m.weight.shape[0] + feature['stride'] = m.stride[0] + feature['kernel'] = m.kernel_size[0] + feature['param'] = np.prod(m.weight.size()) + feature['ifm_size'] = np.prod(m.input_shape_[-2:]) # H*W + feature['prev_action'] = 0.0 # placeholder + + elif isinstance(m, nn.Linear): + feature['conv_dw'] = 0.0 + feature['cin'] = m.in_features + feature['cout'] = m.out_features + feature['stride'] = 0.0 + feature['kernel'] = 1.0 + feature['param'] = np.prod(m.weight.size()) + feature['ifm_size'] = np.prod(m.input_shape_[-1]) # feature nodes + feature['prev_action'] = 0.0 # placeholder + + else: + raise NotImplementedError("State embedding extraction of {}".format(m.__class__.__name__)) + + elif isinstance(qid, NonWeightQuantizerId): + qmod = self.qctrl.all_quantizations[qid] + input_shape = qmod.input_shape_ + output_shape = qmod.output_shape_ + feature['cin'] = input_shape[1] if len(input_shape) == 4 else input_shape[-1] + feature['cout'] = output_shape[1] if len(output_shape) == 4 else output_shape[-1] + feature['ifm_size'] = np.prod(input_shape[-2:]) if len(input_shape) == 4 else input_shape[-1] + feature['conv_dw'] = 0.0 + feature['stride'] = 0.0 + feature['kernel'] = 0.0 + feature['param'] = 0.0 + feature['prev_action'] = 0.0 + + if len(input_shape) != 4 and len(input_shape) != 2: + raise NotImplementedError("A design is required to cater this scenario. Pls. report to maintainer") + + elif isinstance(qid, InputQuantizerId): + raise NotImplementedError("InputQuantizerId is supported, quantizer of nncf model input " + "is of type NonWeightQuantizerId") + + elif isinstance(qid, FunctionQuantizerId): + raise NotImplementedError("FunctionQuantizerId is supported, Pls. report to maintainer") + + else: + raise ValueError("qid is an instance of unexpected class {}".format(qid.__class__.__name__)) + + return pd.Series(feature) + + + def _evaluate_pretrained_model(self): + logger.info("[Q.Env] Evaluating Pretrained Model") + self.qctrl.disable_weight_quantization() + self.qctrl.disable_activation_quantization() + + with torch.no_grad(): + self.pretrained_score = self.eval_fn(self.qmodel, self.eval_loader) + logger.info("Pretrained Score: {:.3f}".format(self.pretrained_score)) + + self.qctrl.enable_weight_quantization() + self.qctrl.enable_activation_quantization() + self.qmodel.rebuild_graph() + + + def _run_quantization_pipeline(self, finetune=False) -> float: + self.qctrl.run_batchnorm_adaptation(self.qctrl.quantization_config) + + if finetune: + raise NotImplementedError("Post-Quantization fine tuning is not implemented.") + with torch.no_grad(): + quantized_score = self.eval_fn(self.qmodel, self.eval_loader) + logger.info("[Q.Env] Quantized Score: {:.3f}".format(quantized_score)) + return quantized_score + + + def _get_quantizer_bitwidth(self) -> Dict[BaseQuantizer, int]: + assert len(set(self.model_bitwidth_space) - set(self.master_df.action.values)) >= 0, \ + "there is bitwidth choice not within model bitwidth space" + return OrderedDict(zip(self.master_df.qid_obj, self.master_df.action)) + + + def _constrain_model_size(self, collected_strategy: List, skip=False) -> List: + def lower_bitwidth(bw: int, bw_space: List[int]) -> int: + return bw_space[bw_space.index(bw)-1] if bw_space.index(bw) > 0 else bw + + # This function acts on self.master_df['action'] + self.master_df['action'] = collected_strategy + + if skip is not True: + self.master_df['unconstrained_action'] = self.master_df['action'] + + current_model_size = self.model_size_calculator(self._get_quantizer_bitwidth()) + + while self.min_model_size < current_model_size and self.target_model_size < current_model_size: + for _, nodestr in enumerate(reversed(self.master_df.index.tolist())): + if self.master_df.loc[nodestr, "is_wt_quantizer"]: + bw_choice, bw_space = self.master_df.loc[nodestr, ['action', 'bw_space']] + new_bw = lower_bitwidth(bw_choice, bw_space) + self.master_df.loc[nodestr, "action"] = new_bw if new_bw != bw_choice else bw_choice + + current_model_size = self.model_size_calculator(self._get_quantizer_bitwidth()) + if current_model_size <= self.target_model_size: + break + else: + logger.info("[Q.Env] Skipping Model Size Constraint") + + return self.master_df['action'].tolist() + + def reward(self, acc: float, model_ratio: float) -> float: + return (acc - self.pretrained_score) * 0.1 + + def step(self, action: Union[int, float]) -> Tuple: + def is_final_step(): + return len(self.collected_strategy) == len(self.master_df) + + # Ensure action is in the quantizer's bitwidth space + current_bw_space = self.master_df.bw_space[len(self.collected_strategy)] + if action not in current_bw_space: + closest_bw_idx = np.argmin(np.abs(action - np.array(current_bw_space))) + action = current_bw_space[closest_bw_idx] + + self.collected_strategy.append(action) + + if not is_final_step(): + info_set = {} + reward = 0 + self.set_next_step_prev_action(len(self.collected_strategy), action) + obs = self.get_normalized_obs(len(self.collected_strategy)) + done = False + return obs, reward, done, info_set + + return self.evaluate_strategy(self.collected_strategy, skip_constraint=self.skip_constraint) + + def evaluate_strategy(self, collected_strategy: List, skip_constraint=True) -> Tuple: + assert len(collected_strategy) == len(self.master_df) + if skip_constraint is not True: + collected_strategy = self._constrain_model_size(collected_strategy) + self.master_df['action'] = collected_strategy # This must be after constraint + + qid_bw_map = dict(zip(self.master_df.qid_obj, self.master_df.action)) + self.set_quantizer_bitwidth(qid_bw_map) + + for idx, qid in zip(self.master_df.index, self.master_df['qid']): + logger.info("[Q.Env] {:50} | {}".format( + str(self.qctrl.all_quantizations[find_qid_by_str(self.qctrl, qid)]), + idx)) + + quantized_score = self._run_quantization_pipeline(finetune=self.finetune) + + current_model_size = self.model_size_calculator(self._get_quantizer_bitwidth()) + current_model_ratio = self.model_size_calculator.get_model_size_ratio(self._get_quantizer_bitwidth()) + + reward = self.reward(quantized_score, current_model_ratio) + + info_set = {'model_ratio': current_model_ratio, 'accuracy': quantized_score, 'model_size': current_model_size} + + obs = self.get_normalized_obs(len(collected_strategy)-1) + done = True + + return obs, reward, done, info_set + + + def set_next_step_prev_action(self, idx, action): + self.master_df.loc[self.master_df.index[idx], 'prev_action'] = action + + + def get_normalized_obs(self, idx: int) -> pd.Series: + _df = self.master_df.loc[self.master_df.index, self.state_list] + _df.loc[_df.index, self.state_list] = self.state_scaler.transform(_df[self.state_list]) + return _df.iloc[idx] + + + def set_quantizer_bitwidth(self, qid_bw_map: Dict[QuantizerId, int]): + self.qmodel.load_state_dict(self.qmodel_init_sd) + for qid, bw in qid_bw_map.items(): + self.qctrl.all_quantizations[qid].num_bits = int(bw) + + + def _generate_qid_nodekey_map(self, + quantization_controller: QuantizationController, + quantized_network: NNCFNetwork) -> Dict[QuantizerId, str]: + """ + Create a lookup mapping for each QuantizerId to its corresponding quantize node in network graph + :param quantization_controller: + :param quantized_network: + :return: dict with key of QuantizerId and value of node key string + """ + # Map Non Weight Qid to its nodes in nxgraph + weight_quantize_nodekeys = [] + non_weight_quantize_nodekeys = [] + qid_nodekey_map = OrderedDict() + + quantized_network.rebuild_graph() + g = quantized_network.get_graph() + + for nodekey in g.get_all_node_keys(): + if 'symmetric_quantize' in nodekey and 'UpdateWeight' in nodekey: + weight_quantize_nodekeys.append(nodekey) + if 'symmetric_quantize' in nodekey and 'UpdateWeight' not in nodekey: + non_weight_quantize_nodekeys.append(nodekey) + + # Find nodekey of Weight Quantizer + for qid, _ in quantization_controller.weight_quantizers.items(): + quantize_nodekeys = [] + for nodekey in weight_quantize_nodekeys: + if str(qid.scope) in nodekey: + quantize_nodekeys.append(nodekey) + + if len(quantize_nodekeys) == 1: + qid_nodekey_map[qid] = quantize_nodekeys[0] + else: + raise ValueError("Quantize Node not found or More Nodes are found for WQid: {}".format(qid)) + + # Find nodekey of Non-Weight Quantizer + for qid, _ in quantization_controller.non_weight_quantizers.items(): + quantize_nodekeys = [] + for nodekey in non_weight_quantize_nodekeys: + if str(qid.ia_op_exec_context.scope_in_model) in nodekey: + quantize_nodekeys.append(nodekey) + + if len(quantize_nodekeys) > 0: + qid_nodekey_map[qid] = quantize_nodekeys[qid.ia_op_exec_context.call_order] + else: + raise ValueError("Quantize Node not found for NWQid: {}".format(qid)) + + if logger.level == logging.DEBUG: + for qid, nodekey in qid_nodekey_map.items(): + logger.debug("QuantizerId: {}".format(qid)) + logger.debug("\tnodekey: {}".format(nodekey)) + + return qid_nodekey_map + + + def _dump_master_df(self): + self.master_df.drop('state_module', axis=1).to_csv( + osp.join(self.dump_dir, self.model_name + "_quantizable_state_table.csv"), index_label="nodestr") + + + def _dump_quantized_graph(self): + self.qmodel.get_graph().visualize_graph(osp.join(self.dump_dir, "qenv_graph.dot")) + + + def _dump_groups_of_adjacent_quantizers(self): + adj_quantizer_groups = [] + + for i, _ in enumerate(self._groups_of_adjacent_quantizers): + group_members = [] + for _, aq in enumerate(self._groups_of_adjacent_quantizers[i].activation_quantizers): + group_members.append(self.master_df.index[self.master_df.qid == str(aq[0])][0]) + for _, wq in enumerate(self._groups_of_adjacent_quantizers[i].weight_quantizers): + group_members.append(self.master_df.index[self.master_df.qid == str(wq[0])][0]) + adj_quantizer_groups.append(natsorted(group_members)) + + with open(osp.join(self.dump_dir, + self.model_name + "_groups_of_adjacent_quantizers.json"), "w") as DUMP_FH: + json.dump(natsorted(adj_quantizer_groups), DUMP_FH, indent=4) diff --git a/nncf/config_schema.py b/nncf/config_schema.py index 0a5c2ea1859..902298f0704 100644 --- a/nncf/config_schema.py +++ b/nncf/config_schema.py @@ -307,6 +307,20 @@ def with_attributes(schema: Dict, **kwargs) -> Dict: "the layer by number of bits for its " "quantization.", default=1.5), + "eval_subset_ratio": with_attributes(_NUMBER, + description="The desired ratio of dataloader to be iterated " + "during each search iteration of AutoQ precision " + "initialization. Specifically, this ratio applies " + "to the registered autoq_eval_loader via " + "register_default_init_args.", + default=1.0), + "warmup_iter_number": with_attributes(_NUMBER, + description="The number of random policy at the beginning of " + "of AutoQ precision initialization to populate " + "replay buffer with experiences. This key is " + "meant for internal testing use. Users need not " + "to configure.", + default=20), "bitwidth_per_scope": { "type": "array", "items": { @@ -328,9 +342,13 @@ def with_attributes(schema: Dict, **kwargs) -> Dict: " It can be used to accelerate mixed precision" "initialization by using average Hessian " "traces from previous run of HAWQ algorithm."), - "dump_hawq_data": with_attributes(_BOOLEAN, - description="Whether to dump data related to HAWQ algorithm:" - "bitwidth graph, average traces and different plots.", + "dump_init_precision_data": with_attributes(_BOOLEAN, + description="Whether to dump data related to Precision " + "Initialization algorithm. HAWQ dump includes " + "bitwidth graph, average traces and different " + "plots. AutoQ dump includes DDPG agent " + "learning trajectory in tensorboard and " + "mixed-precision environment metadata.", default=True), "bitwidth_assignment_mode": BITWIDTH_ASSIGNMENT_MODE_SCHEMA, }, diff --git a/nncf/initialization.py b/nncf/initialization.py index 8036b0f8c14..62f07ae6201 100644 --- a/nncf/initialization.py +++ b/nncf/initialization.py @@ -1,15 +1,19 @@ +import math + from collections import OrderedDict from functools import partial from typing import Dict, Tuple, Any, Callable import torch +from torch.utils.data import DataLoader from torch.nn.modules.loss import _Loss from nncf.progress_bar import ProgressBar from nncf.quantization.init_range import MinMaxInitializer, ThreeSigmaInitializer, MeanMinMaxInitializer from nncf.quantization.init_range import PercentileInitializer -from nncf.structures import QuantizationPrecisionInitArgs, QuantizationRangeInitArgs, BNAdaptationInitArgs +from nncf.structures import QuantizationPrecisionInitArgs, QuantizationRangeInitArgs, \ + BNAdaptationInitArgs, AutoQPrecisionInitArgs from nncf.utils import objwalk, is_tensor, training_mode_switcher @@ -90,6 +94,31 @@ def wrap_dataloader_for_init(data_loader) -> InitializingDataLoader: return data_loader +class PartialDataLoader: + def __init__(self, regular_data_loader: DataLoader, iter_ratio=1.0): + if iter_ratio < 0.0 or iter_ratio > 1.0: + raise ValueError("iter_ratio must be within 0 to 1 range") + self.data_loader = regular_data_loader + self.batch_size = regular_data_loader.batch_size + self._stop_id = math.ceil(len(self.data_loader)*iter_ratio) + self._batch_id = 0 + + def __iter__(self): + self.data_loader_iter = iter(self.data_loader) + self._batch_id = 0 + return self + + def __next__(self) -> Any: + if self._batch_id < self._stop_id: + loaded_item = next(self.data_loader_iter) + self._batch_id += 1 + return loaded_item + raise StopIteration + + def __len__(self) -> int: + return self._stop_id + + class DataLoaderBaseRunner: def __init__(self, model, init_device: str): self.model = model @@ -225,24 +254,31 @@ def default_criterion_fn(outputs: Any, target: Any, criterion: Any) -> torch.Ten def register_default_init_args(nncf_config: 'NNCFConfig', - train_loader, + train_loader: torch.utils.data.DataLoader, criterion: _Loss = None, criterion_fn: Callable[[Any, Any, _Loss], torch.Tensor] = None, + autoq_eval_fn: Callable[[torch.nn.Module, torch.utils.data.DataLoader], float] = None, + autoq_eval_loader: torch.utils.data.DataLoader = None, device='cuda') -> 'NNCFConfig': + + nncf_config.register_extra_structs([QuantizationRangeInitArgs(data_loader=train_loader, + device=device), + BNAdaptationInitArgs(data_loader=train_loader, + device=device)]) + if criterion: if not criterion_fn: criterion_fn = default_criterion_fn nncf_config.register_extra_structs([QuantizationPrecisionInitArgs(criterion_fn=criterion_fn, criterion=criterion, data_loader=train_loader, - device=device), - QuantizationRangeInitArgs(data_loader=train_loader, - device=device), - BNAdaptationInitArgs(data_loader=train_loader, - device=device)]) - else: - nncf_config.register_extra_structs([QuantizationRangeInitArgs(data_loader=train_loader, - device=device), - BNAdaptationInitArgs(data_loader=train_loader, - device=device)]) + device=device)]) + + if autoq_eval_fn: + if not autoq_eval_loader: + autoq_eval_loader = train_loader + nncf_config.register_extra_structs([AutoQPrecisionInitArgs(data_loader=autoq_eval_loader, + eval_fn=autoq_eval_fn, + nncf_config=nncf_config)]) + return nncf_config diff --git a/nncf/quantization/algo.py b/nncf/quantization/algo.py index 8d2dfeed1f4..7962576a30e 100644 --- a/nncf/quantization/algo.py +++ b/nncf/quantization/algo.py @@ -53,7 +53,7 @@ from nncf.quantization.quantizer_propagation import QuantizerPropagationSolver, QuantizerPropagationStateGraph, \ QuantizersBetweenQuantizableLayers, QuantizerInsertionInfo from nncf.quantization.schedulers import QUANTIZATION_SCHEDULERS -from nncf.structures import QuantizationPrecisionInitArgs, QuantizationRangeInitArgs +from nncf.structures import QuantizationPrecisionInitArgs, QuantizationRangeInitArgs, AutoQPrecisionInitArgs from nncf.utils import get_all_modules_by_type, in_scope_list, is_main_process, should_consider_scope from nncf.utils import get_state_dict_names_with_modules @@ -876,16 +876,6 @@ def __init__(self, target_model: NNCFNetwork, for quantizer in self.all_quantizations.values(): # type: BaseQuantizer quantizer.set_export_mode(export_mode) - if is_main_process() and should_init: - self.initialize_quantizer_params() - - # Staged scheduler must be created after initialized to prevent extra logic with disabled quantizations - params = quantization_config.get('params', None) - self.is_staged_scheduler = bool(params) - if self.is_staged_scheduler: - scheduler_cls = QUANTIZATION_SCHEDULERS.get("staged") - self._scheduler = scheduler_cls(self, params) - if self._collect_compression_metrics: self.metric_store = {} quantizer_setup_type = self.quantization_config.get('quantizer_setup_type') @@ -897,7 +887,18 @@ def __init__(self, target_model: NNCFNetwork, self.non_weight_quantizers)] # These metrics are collected once here and are not updated when the method .statistics() is called self.stable_metric_collectors = [ShareEdgesQuantizedDataPath(target_model)] - self.update_metric_store(True) + + params = quantization_config.get('params', None) + self.is_staged_scheduler = bool(params) + + if is_main_process() and should_init: + self.initialize_quantizer_params() + self.update_metric_store(True) + + # Staged scheduler must be created after initialized to prevent extra logic with disabled quantizations + if self.is_staged_scheduler: + scheduler_cls = QUANTIZATION_SCHEDULERS.get("staged") + self._scheduler = scheduler_cls(self, params) def prepare_for_export(self): for quantizer_id, quantizer in self.all_quantizations.items(): @@ -980,7 +981,7 @@ def init_precision(self): if init_precision_config: precision_init_type = init_precision_config.get('type', 'manual') precision_init_args = None - if precision_init_type != 'manual': + if precision_init_type == 'hawq': try: precision_init_args = self.quantization_config.get_extra_struct(QuantizationPrecisionInitArgs) except KeyError as e: @@ -989,6 +990,15 @@ def init_precision(self): 'but the initializing data loader and loss criterion are not provided as an extra struct. ' 'Refer to `NNCFConfig.register_extra_structs` and the `QuantizationPrecisionInitArgs` ' 'class') from e + elif precision_init_type == 'autoq': + try: + precision_init_args = self.quantization_config.get_extra_struct(AutoQPrecisionInitArgs) + except KeyError: + raise ValueError( + 'Specified Automated precision initialization in the NNCF config, ' + 'but the initializing data loader and loss criterion are not provided as an extra struct. ' + 'Refer to `NNCFConfig.register_extra_structs` and the `AutoQPrecisionInitArgs` ' + 'class') from e init_impl = PrecisionInitializerFactory.create(precision_init_type) initializer = init_impl(self, init_precision_config, precision_init_args) diff --git a/nncf/quantization/init_precision.py b/nncf/quantization/init_precision.py index 18a93eb0a83..4e0afe730dd 100644 --- a/nncf/quantization/init_precision.py +++ b/nncf/quantization/init_precision.py @@ -1,6 +1,6 @@ from .precision_init.hawq_init import HAWQPrecisionInitializer from .precision_init.manual_init import ManualPrecisionInitializer - +from .precision_init.autoq_init import AutoQPrecisionInitializer class PrecisionInitializerFactory: @staticmethod @@ -9,4 +9,6 @@ def create(init_type: str): return ManualPrecisionInitializer if init_type == "hawq": return HAWQPrecisionInitializer + if init_type == "autoq": + return AutoQPrecisionInitializer raise NotImplementedError diff --git a/nncf/quantization/layers.py b/nncf/quantization/layers.py index c18f6c2646c..de621a41908 100644 --- a/nncf/quantization/layers.py +++ b/nncf/quantization/layers.py @@ -200,6 +200,9 @@ def set_export_mode(self, mode: QuantizerExportMode): def run_export_quantization(self, x: torch.Tensor): raise NotImplementedError + def extra_repr(self): + return 'bit={}, ch={}, wt={}'.format( + self.num_bits, self.per_channel, self.is_weights) class QuantizersSwitcher: """ Enables/disables quantizers with saving and restoring original state """ diff --git a/nncf/quantization/precision_init/adjacent_quantizers.py b/nncf/quantization/precision_init/adjacent_quantizers.py index 92194f33bbd..2d90489a709 100644 --- a/nncf/quantization/precision_init/adjacent_quantizers.py +++ b/nncf/quantization/precision_init/adjacent_quantizers.py @@ -62,8 +62,15 @@ def get_group_id_for_quantizer(self, quantizer: BaseQuantizer): qid = id(quantizer) return self._quantizer_per_group_id.get(qid, None) + def get_adjacent_quantizers_by_group_id(self, group_id): + return self._groups_of_adjacent_quantizers[group_id].weight_quantizers + \ + self._groups_of_adjacent_quantizers[group_id].activation_quantizers + def __iter__(self): return iter(self._groups_of_adjacent_quantizers) def __bool__(self): return bool(self._groups_of_adjacent_quantizers) and bool(self._quantizer_per_group_id) + + def __getitem__(self, group_id): + return self._groups_of_adjacent_quantizers[group_id] diff --git a/nncf/quantization/precision_init/autoq_init.py b/nncf/quantization/precision_init/autoq_init.py new file mode 100644 index 00000000000..a0108d61b51 --- /dev/null +++ b/nncf/quantization/precision_init/autoq_init.py @@ -0,0 +1,302 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +from collections import OrderedDict +from typing import Dict, Tuple + +import os + +from nncf.debug import is_debug +from nncf.nncf_logger import logger +from nncf.quantization.quantizer_id import QuantizerId +from nncf.structures import AutoQPrecisionInitArgs + +from pathlib import Path +import os.path as osp +import time +from datetime import datetime +import json +import math +import numpy as np +import pandas as pd +import re +from io import StringIO +from copy import deepcopy +from torch.utils.tensorboard import SummaryWriter + + +class AutoQPrecisionInitializer: + def __init__(self, + algo: 'QuantizationController', + init_precision_config: 'NNCFConfig', + init_args: AutoQPrecisionInitArgs): + self.quantization_controller = algo + self.init_args = init_args + + + def apply_init(self): + from nncf.automl.environment.quantization_env import QuantizationEnv + from nncf.automl.agent.ddpg.ddpg import DDPG + from nncf.debug import DEBUG_LOG_DIR + + self.autoq_cfg = self.init_args.config['compression']['initializer']['precision'] + self._dump_autoq_data = self.autoq_cfg.get('dump_init_precision_data', False) + + if self._dump_autoq_data or is_debug(): + dump_dir = self.init_args.config.get('log_dir', None) + if dump_dir is None: + dump_dir = DEBUG_LOG_DIR + self.dump_dir = Path(dump_dir) / Path("autoq_agent_dump") + self.dump_dir.mkdir(parents=True, exist_ok=True) + + self.policy_dict = OrderedDict() #key: episode + self.best_policy_dict = OrderedDict() #key: episode + + self.init_args.config['episodic_nncfcfg'] = osp.join(self.dump_dir, "episodic_nncfcfg") + os.makedirs(self.init_args.config['episodic_nncfcfg'], exist_ok=True) + + self.tb_writer = SummaryWriter(self.dump_dir) + + # log compression config to tensorboard + self.tb_writer.add_text('AutoQ/run_config', + json.dumps(self.init_args.config['compression'], + indent=4, sort_keys=False).replace("\n", "\n\n"), 0) + + + start_ts = datetime.now() + + # Instantiate Quantization Environment + env = QuantizationEnv( + self.quantization_controller, + self.init_args.data_loader, + self.init_args.eval_fn, + self.init_args.config) + + nb_state = len(env.state_list) + nb_action = 1 + + # Instantiate Automation Agent + agent = DDPG(nb_state, nb_action, hparam_override=self.autoq_cfg) + + if self._dump_autoq_data: + self.tb_writer.add_text('AutoQ/state_embedding', env.master_df[env.state_list].to_markdown()) + + best_policy, best_reward = self._search(agent, env) + + end_ts = datetime.now() + + self.set_chosen_config(dict(zip(env.master_df.qid_obj, best_policy))) + + logger.info('[AutoQ] best_reward: {}'.format(best_reward)) + logger.info('[AutoQ] best_policy: {}'.format(best_policy)) + logger.info("[AutoQ] Search Complete") + logger.info("[AutoQ] Elapsed time of AutoQ Precision Initialization (): {}".format(end_ts-start_ts)) + + + def set_chosen_config(self, qid_bw_map: Dict[QuantizerId, int]): + for qid, bw in qid_bw_map.items(): + self.quantization_controller.all_quantizations[qid].num_bits = bw + + + def _search(self, agent: 'DDPG', env: 'QuantizationEnv') -> Tuple[pd.Series, float]: + best_reward = -math.inf + episode = 0 + episode_reward = 0. + observation = None + T = [] # Transition buffer + + while episode < self.autoq_cfg['iter_number']: # counting based on episode + episode_start_ts = time.time() + if observation is None: + # reset if it is the start of episode + env.reset() + observation = deepcopy(env.get_normalized_obs(0)) + agent.reset(observation) + + if episode < agent.warmup_iter_number: + action = agent.random_action() + else: + action = agent.select_action(observation, episode=episode) + + # env response with next_observation, reward, terminate_info + observation2, reward, done, info = env.step(map_precision(action)) + observation2 = deepcopy(observation2) + T.append([reward, deepcopy(observation), deepcopy(observation2), action, done]) + + # update + episode_reward += reward + observation = deepcopy(observation2) + + if done: # end of episode + logger.info( + '## Episode[{}], reward: {:.3f}, acc: {:.3f}, model_ratio: {:.3f}, model_size(MB): {:.2f}\n' \ + .format(episode, episode_reward, info['accuracy'], info['model_ratio'], info['model_size']/8e6)) + + final_reward = T[-1][0] + + for i, (_, s_t, _, a_t, done) in enumerate(T): + # Revision of prev_action as it could be modified by constrainer ------- + if i == 0: + prev_action = 0.0 + else: + prev_action = env.master_df['action'][i-1] / 8 #ducktape scaling + if prev_action != s_t['prev_action']: + s_t['prev_action'] = prev_action + # EO ------------------------ + + agent.observe(final_reward, s_t, a_t, done) + if episode >= agent.warmup_iter_number: + for _ in range(agent.n_update): + agent.update_policy() + + agent.memory.append( + observation, + agent.select_action(observation, episode=episode), + 0., False + ) + + # reset + observation = None + episode_reward = 0. + T = [] + + value_loss = agent.get_value_loss() + policy_loss = agent.get_policy_loss() + delta = agent.get_delta() + + bit_stats_tt = env.qctrl.statistics()['Bitwidth distribution:'] + bit_stats_tt.set_max_width(100) + bit_stats_df = pd.read_csv( + StringIO(re.sub( + r'[-+|=]', '', bit_stats_tt.draw())), sep=r'\s{2,}', engine='python').reset_index(drop=True) + + if final_reward > best_reward: + best_reward = final_reward + best_policy = env.master_df['action'] + info_tuple = (episode, best_reward, info['accuracy'], info['model_ratio']) + self._dump_best_episode(info_tuple, bit_stats_df, env) + log_str = '## Episode[{}] New best policy: {}, reward: {:.3f}, acc: {:.3f}, model_ratio: {:.3f}'\ + .format(episode, best_policy.values.tolist(), best_reward, + info['accuracy'], info['model_ratio']) + logger.info("\033[92m {}\033[00m" .format(log_str)) + + episodic_info_tuple = (episode, final_reward, best_reward, + info['accuracy'], info['model_ratio'], + value_loss, policy_loss, delta) + self._dump_episode(episodic_info_tuple, bit_stats_df, env, agent) + + episode_elapsed = time.time() - episode_start_ts + + logger.info('## Episode[{}] Policy: \n{}\n'.format(episode, env.master_df['action'].to_string())) + logger.info('## Episode[{}] Elapsed: {:.3f}\n'.format(episode, episode_elapsed)) + + episode += 1 + + return best_policy, best_reward + + + def _dump_best_episode(self, info_tuple: Tuple, bit_stats_df: pd.DataFrame, env: 'QuantizationEnv'): + if self._dump_autoq_data: + episode = info_tuple[0] + self.best_policy_dict[episode] = env.master_df['action'].astype('int') + + pd.DataFrame( + self.best_policy_dict.values(), index=self.best_policy_dict.keys()).T.sort_index( + axis=1, ascending=False).to_csv( + osp.join(self.dump_dir, "best_policy.csv"), index_label="nodestr") + + best_policy_string = self._generate_tensorboard_logging_string( + bit_stats_df, env.master_df, info_tuple, env.skip_constraint) + self.tb_writer.add_text('AutoQ/best_policy', best_policy_string, episode) + + + def _dump_episode(self, + episodic_info_tuple: Tuple, bit_stats_df: pd.DataFrame, + env: 'QuantizationEnv', agent: 'DDPG'): + if self._dump_autoq_data: + episode, final_reward, _, accuracy, model_ratio, _, _, _ = episodic_info_tuple + + # Save nncf compression cfg + episode_cfgfile = osp.join(env.config['episodic_nncfcfg'], '{0:03d}_nncfcfg.json'.format(episode)) + with open(episode_cfgfile, "w") as outfile: + json.dump(env.config, outfile, indent=4, sort_keys=False) + + self.policy_dict[episode] = env.master_df['action'].astype('int') + pd.DataFrame( + self.policy_dict.values(), index=self.policy_dict.keys()).T.sort_index(axis=1, ascending=False).to_csv( + osp.join(self.dump_dir, "policy_per_episode.csv"), index_label="nodestr") + + # log current episode policy and feedback as text + info_tuple = (episode, final_reward, accuracy, model_ratio) + current_strategy_string = self._generate_tensorboard_logging_string( + bit_stats_df, env.master_df, info_tuple, env.skip_constraint) + self.tb_writer.add_text('AutoQ/current_policy', current_strategy_string, episode) + + # visualization over episode + self._add_to_tensorboard(self.tb_writer, episodic_info_tuple) + + if episode % int((self.autoq_cfg['iter_number']+10)/10) == 0: + agent.save_model(self.dump_dir) + + + def _add_to_tensorboard(self, tb_writer: SummaryWriter, log_tuple: Tuple): + episode, final_reward, best_reward, \ + accuracy, model_ratio, value_loss, \ + policy_loss, delta = log_tuple + + tb_writer.add_scalar('AutoQ/reward/last', final_reward, episode) + tb_writer.add_scalar('AutoQ/reward/best', best_reward, episode) + tb_writer.add_scalar('AutoQ/accuracy', accuracy, episode) + tb_writer.add_scalar('AutoQ/model_ratio', model_ratio, episode) + tb_writer.add_scalar('AutoQ/agent/value_loss', value_loss, episode) + tb_writer.add_scalar('AutoQ/agent/policy_loss', policy_loss, episode) + tb_writer.add_scalar('AutoQ/agent/delta', delta, episode) + + + def _generate_tensorboard_logging_string(self, + bit_stats_df: pd.DataFrame, master_df: pd.DataFrame, + info_tuple: Tuple, skip_constraint=False) -> str: + qdf = master_df # For readibility + episode, reward, accuracy, model_ratio = info_tuple + + text_string = bit_stats_df.to_markdown() + "\n\n\n" + text_string += "Episode: {:>4}, Reward: {:.3f}, ".format(episode, reward) + text_string += "Accuracy: {:.3f}, Model_Size_Ratio: {:.3f}\n\n\n".format(accuracy, model_ratio) + + for _, row_id in enumerate(qdf.index.tolist()): + Qtype = '(WQ)' if qdf.is_wt_quantizer[row_id] else '(AQ)' + + if skip_constraint is False and \ + qdf.loc[row_id, 'action'] != qdf.loc[row_id, 'unconstrained_action']: + + text_string += "\t{} <= {} | {} {} \n".format( + str(int(qdf.loc[row_id, 'action'])), str(int(qdf.loc[row_id, 'unconstrained_action'])), + Qtype, row_id) + + else: + text_string += "\t{} | {} {} \n".format( + str(int(qdf.loc[row_id, 'action'])), Qtype, row_id) + + return text_string + +def map_precision(action: float) -> int: + precision_set = [2, 4, 8] + precision_set = np.array(sorted(precision_set)) + tuned_point = precision_set+3 + max_bit = max(precision_set) + + i = None + for i, point in enumerate(tuned_point): + if action <= 2**point/2**max_bit: + return int(precision_set[i]) + return int(precision_set[i]) diff --git a/nncf/quantization/precision_init/hawq_init.py b/nncf/quantization/precision_init/hawq_init.py index 20ffd0e0640..660d29a7aea 100644 --- a/nncf/quantization/precision_init/hawq_init.py +++ b/nncf/quantization/precision_init/hawq_init.py @@ -68,7 +68,7 @@ def __init__(self, algo: 'QuantizationController', config: 'NNCFConfig', self._init_device = init_args.device self.flops_counter = CompressionRatioCalculator(self._model, self._quantizers_handler) self._groups_of_adjacent_quantizers = GroupsOfAdjacentQuantizers(algo) - self._dump_hawq_data = config.get('dump_hawq_data', False) + self._dump_hawq_data = config.get('dump_init_precision_data', False) bitwidth_assignment_mode_str = config.get('bitwidth_assignment_mode', BitwidthAssignmentMode.LIBERAL.value) self._bitwidth_assignment_mode = BitwidthAssignmentMode.from_str(bitwidth_assignment_mode_str) diff --git a/nncf/structures.py b/nncf/structures.py index aaeedc64fa4..3f54c5e7a7b 100644 --- a/nncf/structures.py +++ b/nncf/structures.py @@ -89,3 +89,15 @@ def __init__(self, data_loader: DataLoader, device: str = 'cuda'): @classmethod def get_id(cls) -> str: return "bn_adaptation_init_args" + +class AutoQPrecisionInitArgs(NNCFExtraConfigStruct): + def __init__(self, data_loader: DataLoader, + eval_fn: Callable[[torch.nn.Module, torch.utils.data.DataLoader], float], + nncf_config: 'NNCFConfig'): + self.data_loader = data_loader + self.eval_fn = eval_fn + self.config = nncf_config + + @classmethod + def get_id(cls) -> str: + return "autoq_precision_init_args" diff --git a/setup.py b/setup.py index 125a850708c..d98e76ad1e4 100644 --- a/setup.py +++ b/setup.py @@ -66,7 +66,9 @@ def find_version(*file_paths): "defusedxml==0.7.0rc1", "mlflow==1.12.1", "returns==0.14", - "pandas==1.1.5"] + "pandas==1.1.5", + "natsort", + "sklearn"] DEPENDENCY_LINKS = [] diff --git a/tests/automl/test_ddpg.py b/tests/automl/test_ddpg.py new file mode 100644 index 00000000000..1b78f9951b2 --- /dev/null +++ b/tests/automl/test_ddpg.py @@ -0,0 +1,196 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import pytest +import torch +import numpy as np +from torch.backends import cudnn +from nncf.utils import manual_seed +from nncf.automl.agent.ddpg.ddpg import DDPG + +STUB = 0 +N_STATE = 5 +N_ACTION = 2 +N_HIDDEN_NODE = 3 +SCALAR_ZERO = 0 +SCALAR_ONE = 1 + +VALID_NUM_ACTIONS = [1, 5] +VALID_NUM_STATES = [1, 3] +@pytest.mark.parametrize('num_action', VALID_NUM_ACTIONS, + ids=['_'.join(['num_action', str(a)]) for a in VALID_NUM_ACTIONS]) +@pytest.mark.parametrize('num_state', VALID_NUM_STATES, + ids=['_'.join(['num_state', str(s)]) for s in VALID_NUM_STATES]) +def test_create_ddpg_with_valid_input(num_state, num_action): + DDPG(num_state, num_action, {}) + + +INVALID_VALUES = [2.5, 0, -1, None, "string"] +@pytest.mark.parametrize('num_action', INVALID_VALUES, + ids=['_'.join(['num_action', str(v)]) for v in INVALID_VALUES]) +@pytest.mark.parametrize('num_state', INVALID_VALUES, + ids=['_'.join(['num_state', str(v)]) for v in INVALID_VALUES]) +def test_create_ddpg_with_invalid_input(num_state, num_action): + with pytest.raises((TypeError, ZeroDivisionError, RuntimeError)): + DDPG(num_state, num_action, {}) + + +def test_random_action(): + ddpg = DDPG(N_STATE, N_ACTION) + randomized_action = ddpg.random_action() + assert randomized_action.shape[0] == N_ACTION + # check action value within bound + assert sum((randomized_action >= ddpg.LBOUND) & (randomized_action <= ddpg.RBOUND)) == N_ACTION + +@pytest.fixture +def _seed(): + cudnn.deterministic = True + cudnn.benchmark = False + manual_seed(0) + + +EPISODE_NOISY_ACTION_TUPLES = [ + (0, [0.71018179, 0.82288581]), + (10, [0.72084132, 0.82954315]), + (100, [0.81406932, 0.88682551]), + (1000, [0.99795472, 0.99875519]), +] +@pytest.mark.parametrize('episode_action_pair', EPISODE_NOISY_ACTION_TUPLES, + ids=['_'.join(['episode', str(e)]) for e, _ in EPISODE_NOISY_ACTION_TUPLES]) +@pytest.mark.parametrize('decay_epsilon', [True, False], + ids=['_'.join(['actor_with_noise', str(b)]) for b in [True, False]]) +def test_select_action(episode_action_pair, decay_epsilon, _seed): + episode, reference_action = episode_action_pair + + hparams = { + "hidden1": N_HIDDEN_NODE, + "hidden2": N_HIDDEN_NODE, + "init_delta": 0.5, + "delta_decay": 0.99, + "warmup_iter_number": 5 + } + + ddpg = DDPG(N_STATE, N_ACTION, hparams) + ddpg.actor.load_state_dict( + {state: torch.ones_like(param) for state, param in ddpg.actor.state_dict().items()} + ) + + s_t = [1.0] * N_STATE + selected_action = ddpg.select_action(s_t, episode, decay_epsilon) + + if decay_epsilon: + np.testing.assert_allclose(selected_action, reference_action) + else: + assert all(selected_action == 1.0) + + +TEST_REFERENCES = [ + {"bs": 4, "discount": 1.0, "is_ma": False, "policy_loss": -0.3665157, "value_loss": 0.25}, + {"bs": 4, "discount": 0.9, "is_ma": True, "policy_loss": -0.3568782, "value_loss": 0.0013081}, + {"bs": 8, "discount": 1.0, "is_ma": True, "policy_loss": -0.3616864, "value_loss": 0}, + {"bs": 8, "discount": 0.8, "is_ma": False, "policy_loss": -0.3665157, "value_loss": 0.1828955}, +] +@pytest.mark.parametrize('test_vector', TEST_REFERENCES, + ids=['batch_size_{}-discount_factor_{}-moving_avg_{}' \ + .format(d['bs'], d['discount'], d['is_ma']) for d in TEST_REFERENCES]) +def test_update_policy(test_vector, mocker, _seed): + batch_size, discount, is_movingavg, ref_policy_loss, ref_value_loss = test_vector.values() + + mocked_trace = mocker.patch('nncf.automl.agent.ddpg.memory.SequentialMemory.sample_and_split') + # state_batch, action_batch, reward_batch, next_state_batch, terminal_batch + mocked_trace.return_value = ( + np.ones((batch_size, N_STATE)), + np.ones((batch_size, N_ACTION)), + np.ones((batch_size, SCALAR_ONE)), + np.ones((batch_size, N_STATE)), + np.ones((batch_size, SCALAR_ONE)), + ) + + hparams = { + "hidden1": N_HIDDEN_NODE, + "hidden2": N_HIDDEN_NODE, + "bsize": batch_size, + "discount": discount, + "window_length": SCALAR_ONE, + } + + ddpg = DDPG(N_STATE, N_ACTION, hparams) + ddpg.actor.load_state_dict( + {state: torch.ones_like(param)/2 for state, param in ddpg.actor.state_dict().items()} + ) + ddpg.actor_target.load_state_dict( + {state: torch.ones_like(param) for state, param in ddpg.actor_target.state_dict().items()} + ) + + ddpg.moving_average = is_movingavg + ddpg.update_policy() + np.testing.assert_almost_equal(ddpg.policy_loss.item(), ref_policy_loss) + np.testing.assert_almost_equal(ddpg.value_loss.item(), ref_value_loss) + + +TAU = 0.1 +def create_two_ddpg_agents(): + source_ddpg = DDPG(N_STATE, N_ACTION, {"hidden1": N_HIDDEN_NODE, "hidden2": N_HIDDEN_NODE, "tau": TAU}) + source_ddpg.actor.load_state_dict( + {state: torch.ones_like(param)/2 for state, param in source_ddpg.actor.state_dict().items()} + ) + + target_ddpg = DDPG(N_STATE, N_ACTION, {"hidden1": N_HIDDEN_NODE, "hidden2": N_HIDDEN_NODE, "tau": TAU}) + target_ddpg.actor.load_state_dict( + {state: torch.ones_like(param) for state, param in target_ddpg.actor.state_dict().items()} + ) + return source_ddpg, target_ddpg + + +def test_soft_update(): + source_ddpg, target_ddpg = create_two_ddpg_agents() + target_ddpg.soft_update(target_ddpg.actor, source_ddpg.actor) + + for _, state_tensor in target_ddpg.actor.state_dict().items(): + assert torch.all(state_tensor == 0.95).item() + + +def test_hard_update(): + source_ddpg, target_ddpg = create_two_ddpg_agents() + target_ddpg.hard_update(target_ddpg.actor, source_ddpg.actor) + + for _, state_tensor in target_ddpg.actor.state_dict().items(): + assert torch.all(state_tensor == 0.5).item() + + +REPLAY_MEMORY_SIZE = 5 +def test_observe(): + def check_replay_buffer_size(length): + assert ddpg.memory.limit == REPLAY_MEMORY_SIZE + assert len(ddpg.memory.actions) == length + assert len(ddpg.memory.rewards) == length + assert len(ddpg.memory.terminals) == length + assert len(ddpg.memory.observations) == length + + ddpg = DDPG(N_STATE, N_ACTION, {"rmsize": REPLAY_MEMORY_SIZE}) + check_replay_buffer_size(SCALAR_ZERO) + + reward_t = SCALAR_ZERO + states_t = [SCALAR_ZERO] * N_STATE + action_t = [SCALAR_ZERO] * N_ACTION + is_done_t = True + + ddpg.observe(reward_t, states_t, action_t, is_done_t) + check_replay_buffer_size(SCALAR_ONE) + + # Replay Buffer Appending is disabled in non-training mode + # size of experience must stay as the same as above + ddpg.is_training = False + ddpg.observe(reward_t, states_t, action_t, is_done_t) + ddpg.observe(reward_t, states_t, action_t, is_done_t) + check_replay_buffer_size(SCALAR_ONE) diff --git a/tests/automl/test_memory.py b/tests/automl/test_memory.py new file mode 100644 index 00000000000..ea7d3daa333 --- /dev/null +++ b/tests/automl/test_memory.py @@ -0,0 +1,274 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +# Modification Notes: +# This unit test is adapted from: +# https://github.com/keras-rl/keras-rl/blob/master/tests/rl/test_memory.py + + +import numpy as np +from numpy.testing import assert_allclose +from nncf.automl.agent.ddpg.memory import Memory, SequentialMemory + + +WINDOW_LENGTH = 5 +LIMIT = 5 +MAX_LEN = 10 + +def test_can_create_memory(): + Memory(WINDOW_LENGTH) + SequentialMemory(LIMIT, window_length=WINDOW_LENGTH) + + +def test_get_recent_state_with_episode_boundaries(): + memory = SequentialMemory(3, window_length=2, ignore_episode_boundaries=False) + obs_size = (3, 4) + + obs0 = np.random.random(obs_size) + + obs1 = np.random.random(obs_size) + terminal1 = False + + obs2 = np.random.random(obs_size) + terminal2 = False + + obs3 = np.random.random(obs_size) + terminal3 = True + + obs4 = np.random.random(obs_size) + terminal4 = False + + obs5 = np.random.random(obs_size) + terminal5 = True + + obs6 = np.random.random(obs_size) + terminal6 = False + + state = np.array(memory.get_recent_state(obs0)) + assert state.shape == (2,) + obs_size + assert np.allclose(state[0], 0.) + assert np.all(state[1] == obs0) + + # memory.append takes the current observation, the reward after taking an action and if + # the *new* observation is terminal, thus `obs0` and `terminal1` is correct. + memory.append(obs0, 0, 0., terminal1) + state = np.array(memory.get_recent_state(obs1)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs0) + assert np.all(state[1] == obs1) + + memory.append(obs1, 0, 0., terminal2) + state = np.array(memory.get_recent_state(obs2)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs1) + assert np.all(state[1] == obs2) + + memory.append(obs2, 0, 0., terminal3) + state = np.array(memory.get_recent_state(obs3)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs2) + assert np.all(state[1] == obs3) + + memory.append(obs3, 0, 0., terminal4) + state = np.array(memory.get_recent_state(obs4)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == np.zeros(obs_size)) + assert np.all(state[1] == obs4) + + memory.append(obs4, 0, 0., terminal5) + state = np.array(memory.get_recent_state(obs5)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs4) + assert np.all(state[1] == obs5) + + memory.append(obs5, 0, 0., terminal6) + state = np.array(memory.get_recent_state(obs6)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == np.zeros(obs_size)) + assert np.all(state[1] == obs6) + + +def test_training_flag(): + obs_size = (3, 4) + + obs0 = np.random.random(obs_size) + + obs1 = np.random.random(obs_size) + terminal1 = True + + obs2 = np.random.random(obs_size) + terminal2 = False + + for training in (True, False): + memory = SequentialMemory(3, window_length=2) + + state = np.array(memory.get_recent_state(obs0)) + assert state.shape == (2,) + obs_size + assert np.allclose(state[0], 0.) + assert np.all(state[1] == obs0) + assert memory.nb_entries == 0 + + memory.append(obs0, 0, 0., terminal1, training=training) + state = np.array(memory.get_recent_state(obs1)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs0) + assert np.all(state[1] == obs1) + if training: + assert memory.nb_entries == 1 + else: + assert memory.nb_entries == 0 + + memory.append(obs1, 0, 0., terminal2, training=training) + state = np.array(memory.get_recent_state(obs2)) + assert state.shape == (2,) + obs_size + assert np.allclose(state[0], 0.) + assert np.all(state[1] == obs2) + if training: + assert memory.nb_entries == 2 + else: + assert memory.nb_entries == 0 + + +def test_get_recent_state_without_episode_boundaries(): + memory = SequentialMemory(3, window_length=2, ignore_episode_boundaries=True) + obs_size = (3, 4) + + obs0 = np.random.random(obs_size) + + obs1 = np.random.random(obs_size) + terminal1 = False + + obs2 = np.random.random(obs_size) + terminal2 = False + + obs3 = np.random.random(obs_size) + terminal3 = True + + obs4 = np.random.random(obs_size) + terminal4 = False + + obs5 = np.random.random(obs_size) + terminal5 = True + + obs6 = np.random.random(obs_size) + terminal6 = False + + state = np.array(memory.get_recent_state(obs0)) + assert state.shape == (2,) + obs_size + assert np.allclose(state[0], 0.) + assert np.all(state[1] == obs0) + + # memory.append takes the current observation, the reward after taking an action and if + # the *new* observation is terminal, thus `obs0` and `terminal1` is correct. + memory.append(obs0, 0, 0., terminal1) + state = np.array(memory.get_recent_state(obs1)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs0) + assert np.all(state[1] == obs1) + + memory.append(obs1, 0, 0., terminal2) + state = np.array(memory.get_recent_state(obs2)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs1) + assert np.all(state[1] == obs2) + + memory.append(obs2, 0, 0., terminal3) + state = np.array(memory.get_recent_state(obs3)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs2) + assert np.all(state[1] == obs3) + + memory.append(obs3, 0, 0., terminal4) + state = np.array(memory.get_recent_state(obs4)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs3) + assert np.all(state[1] == obs4) + + memory.append(obs4, 0, 0., terminal5) + state = np.array(memory.get_recent_state(obs5)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs4) + assert np.all(state[1] == obs5) + + memory.append(obs5, 0, 0., terminal6) + state = np.array(memory.get_recent_state(obs6)) + assert state.shape == (2,) + obs_size + assert np.all(state[0] == obs5) + assert np.all(state[1] == obs6) + + +def test_sampling(): + memory = SequentialMemory(100, window_length=2, ignore_episode_boundaries=False) + obs_size = (3, 4) + actions = range(5) + + obs0 = np.random.random(obs_size) + action0 = np.random.choice(actions) + reward0 = np.random.random() + + obs1 = np.random.random(obs_size) + terminal1 = False + action1 = np.random.choice(actions) + reward1 = np.random.random() + + obs2 = np.random.random(obs_size) + terminal2 = False + action2 = np.random.choice(actions) + reward2 = np.random.random() + + obs3 = np.random.random(obs_size) + terminal3 = True + action3 = np.random.choice(actions) + reward3 = np.random.random() + + obs4 = np.random.random(obs_size) + terminal4 = False + action4 = np.random.choice(actions) + reward4 = np.random.random() + + obs5 = np.random.random(obs_size) + terminal5 = False + action5 = np.random.choice(actions) + reward5 = np.random.random() + + terminal6 = False + + # memory.append takes the current observation, the reward after taking an action and if + # the *new* observation is terminal, thus `obs0` and `terminal1` is correct. + memory.append(obs0, action0, reward0, terminal1) + memory.append(obs1, action1, reward1, terminal2) + memory.append(obs2, action2, reward2, terminal3) + memory.append(obs3, action3, reward3, terminal4) + memory.append(obs4, action4, reward4, terminal5) + memory.append(obs5, action5, reward5, terminal6) + assert memory.nb_entries == 6 + + experiences = memory.sample(batch_size=3, batch_idxs=[2, 3, 4]) + assert len(experiences) == 3 + + assert_allclose(experiences[0].state0, np.array([obs1, obs2])) + assert_allclose(experiences[0].state1, np.array([obs2, obs3])) + assert experiences[0].action == action2 + assert experiences[0].reward == reward2 + assert experiences[0].terminal1 is True + + # Next experience has been re-sampled since since state0 would be terminal in which case we + # cannot really have a meaningful transition because the environment gets reset. We thus + # just ensure that state0 is not terminal. + assert not np.all(experiences[1].state0 == np.array([obs2, obs3])) + + assert_allclose(experiences[2].state0, np.array([np.zeros(obs_size), obs4])) + assert_allclose(experiences[2].state1, np.array([obs4, obs5])) + assert experiences[2].action == action4 + assert experiences[2].reward == reward4 + assert experiences[2].terminal1 is False diff --git a/tests/automl/test_quantization_env.py b/tests/automl/test_quantization_env.py new file mode 100644 index 00000000000..d9ff7206e73 --- /dev/null +++ b/tests/automl/test_quantization_env.py @@ -0,0 +1,140 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import pytest +from nncf.automl.environment.quantization_env import QuantizationEnv, ModelSizeCalculator +from tests.helpers import create_mock_dataloader, BasicConvTestModel, create_compressed_model_and_algo_for_test +from tests.quantization.test_quantization_helpers import get_quantization_config_without_range_init + + +def create_test_quantization_env() -> QuantizationEnv: + model = BasicConvTestModel() + config = get_quantization_config_without_range_init() + config['target_device'] = 'VPU' + _, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) + + config['compression']['initializer']['precision'] = {"type": "autoq"} + data_loader = create_mock_dataloader(config['input_info']) + return QuantizationEnv(compression_ctrl, data_loader, lambda *x: 0, config) + + +def test_can_create_quant_env(): + create_test_quantization_env() + + +QUANTIZER_CFG_TUPLES = [ + ([2, 2], [4, 2]), + ([2, 4], [4, 4]), + ([2, 8], [4, 4]), + ([4, 4], [4, 4]), + ([4, 8], [4, 4]), + ([1, 6], [4, 4]), + ([16, 1], [8, 2]), +] +@pytest.mark.parametrize('bitwidth_cfg_tuple', QUANTIZER_CFG_TUPLES, + ids=['_'.join(['bitwidth_cfg', str(tup[0])]) for tup in QUANTIZER_CFG_TUPLES]) +def test_step(bitwidth_cfg_tuple, mocker): + final_cfg_spy = mocker.spy(ModelSizeCalculator, "__call__") + bitwidth_cfg, final_cfg = bitwidth_cfg_tuple + + qenv = create_test_quantization_env() + + for i, bw in enumerate(bitwidth_cfg): + observation, reward, is_done, info_set = qenv.step(bw) + + # no NaN in observation check + assert not observation.isnull().values.any() + assert reward == 0 + + if i < len(bitwidth_cfg)-1: + assert is_done is False + assert len(info_set) == 0 + else: + assert is_done is True + + # Two factors impact final quantization policg + # 1. Size constraint is enabled by default and targets 0.15 ratio + # 2. Bitwidth space per quantizer. + # Reference final policy is hardened as test truth. + assert list(final_cfg_spy.call_args[0][1].values()) == final_cfg + assert info_set['model_ratio'] == final_cfg[-1]/qenv.model_size_calculator.FLOAT_BITWIDTH + + +def test_overflow_step(): + qenv = create_test_quantization_env() + + for i, bw in enumerate([8, 8, 8]): + if i < len(qenv.qctrl.all_quantizations): + qenv.step(bw) + else: + # Extra stepping where step number is more than + # the number of quantizers should throw IndexError + with pytest.raises(IndexError): + qenv.step(bw) + + +PRETRAINED_SCORE = [74.3, -0.11, None] +COMPRESSED_SCORE = [0.12, -7.23, "dummy"] +MODEL_SIZE_RATIO = [0.120, 2, False] + +@pytest.mark.parametrize('model_size_ratio', MODEL_SIZE_RATIO, + ids=['_'.join(['size_ratio', str(r)]) for r in MODEL_SIZE_RATIO]) +@pytest.mark.parametrize('compressed_score', COMPRESSED_SCORE, + ids=['_'.join(['compressed_score', str(s)]) for s in COMPRESSED_SCORE]) +@pytest.mark.parametrize('pretrained_score', PRETRAINED_SCORE, + ids=['_'.join(['pretrained_score', str(s)]) for s in PRETRAINED_SCORE]) +def test_reward(pretrained_score, compressed_score, model_size_ratio): + qenv = create_test_quantization_env() + qenv.pretrained_score = pretrained_score + + if any(map(lambda x: not isinstance(x, (int, float)), + [pretrained_score, compressed_score, model_size_ratio])): + with pytest.raises(TypeError): + qenv.reward(compressed_score, model_size_ratio) + else: + reward = qenv.reward(compressed_score, model_size_ratio) + assert reward == (compressed_score - pretrained_score) * 0.1 + + +STRATEGY_LIST = [ + [2], + [8, 8], + [4, 8, 2] +] + +SKIP_CONSTRAINT_BOOL = [True, False] + +@pytest.mark.parametrize('skip_bool', SKIP_CONSTRAINT_BOOL, + ids=['_'.join(['skip_constraint', str(s)]) for s in SKIP_CONSTRAINT_BOOL]) +@pytest.mark.parametrize('strategy', STRATEGY_LIST, + ids=['_'.join(['bitwidth_strategy', str(s)]) for s in STRATEGY_LIST]) +def test_evaluate_strategy(strategy, skip_bool, mocker): + final_cfg_spy = mocker.spy(ModelSizeCalculator, "__call__") + qenv = create_test_quantization_env() + + if len(strategy) != len(qenv.qctrl.all_quantizations): + with pytest.raises(AssertionError): + qenv.evaluate_strategy(strategy, skip_constraint=skip_bool) + else: + observation, reward, is_done, info_set = qenv.evaluate_strategy(strategy, skip_constraint=skip_bool) + + evaluated_strategy = list(final_cfg_spy.call_args[0][1].values()) + + assert not observation.isnull().values.any() + assert reward == 0 + assert is_done is True + + if skip_bool is True: + assert info_set['model_ratio'] == strategy[-1]/qenv.model_size_calculator.FLOAT_BITWIDTH + else: + assert info_set['model_ratio'] == evaluated_strategy[-1]/qenv.model_size_calculator.FLOAT_BITWIDTH diff --git a/tests/automl/test_ring_buffer.py b/tests/automl/test_ring_buffer.py new file mode 100644 index 00000000000..fae5d1bbabf --- /dev/null +++ b/tests/automl/test_ring_buffer.py @@ -0,0 +1,51 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +# Modification Notes: +# This unit test is adapted from: +# https://github.com/keras-rl/keras-rl/blob/master/tests/rl/test_memory.py + + +import pytest +from nncf.automl.agent.ddpg.memory import RingBuffer + +MAX_LEN = 3 + + +def test_create_ring_buffer(): + RingBuffer(MAX_LEN) + + +def test_append(): + def assert_elements(b: RingBuffer, ref: RingBuffer): + assert len(b) == len(ref) + for idx in range(b.maxlen): + if idx >= len(ref): + with pytest.raises(KeyError): + _ = b[idx] + else: + assert b[idx] == ref[idx] + + ring_buffer = RingBuffer(MAX_LEN) + for i in range(MAX_LEN): + ring_buffer.append(i) + assert ring_buffer[i] == i + assert len(ring_buffer) == i + 1 + assert_elements(ring_buffer, [0, 1, 2]) + + ring_buffer.append(3) + assert_elements(ring_buffer, [1, 2, 3]) + ring_buffer.append(4) + assert_elements(ring_buffer, [2, 3, 4]) + ring_buffer.append(5) + assert_elements(ring_buffer, [3, 4, 5]) diff --git a/tests/data/configs/hawq/inception_v3_cifar10_mixed_int.json b/tests/data/configs/hawq/inception_v3_cifar10_mixed_int.json index 602426a7531..77f738e1ef3 100644 --- a/tests/data/configs/hawq/inception_v3_cifar10_mixed_int.json +++ b/tests/data/configs/hawq/inception_v3_cifar10_mixed_int.json @@ -1,6 +1,5 @@ { "model": "inception_v3", - "dataset": "CIFAR10", "input_info": { "sample_size": [ 2, diff --git a/tests/data/configs/hawq/inception_v3_cifar10_mixed_int_staged.json b/tests/data/configs/hawq/inception_v3_cifar10_mixed_int_staged.json deleted file mode 100644 index 916877aa8bb..00000000000 --- a/tests/data/configs/hawq/inception_v3_cifar10_mixed_int_staged.json +++ /dev/null @@ -1,37 +0,0 @@ -{ - "model": "inception_v3", - "dataset": "CIFAR10", - "input_info": { - "sample_size": [ - 2, - 3, - 299, - 299 - ] - }, - "num_classes": 10, - "pretrained": false, - "target_device": "VPU", - "compression": [ - { - "algorithm": "quantization", - "initializer": { - "precision": { - "type": "hawq", - "num_data_points": 2, - "iter_number": 1 - }, - "batchnorm_adaptation": { - "num_bn_adaptation_samples": 2, - "num_bn_forget_samples": 1 - }, - "range": { - "num_init_samples": 1 - } - }, - "params": { - "activations_quant_start_epoch": 0 - } - } - ] -} diff --git a/tests/data/configs/hawq/resnet18_cifar10_mixed_int.json b/tests/data/configs/hawq/resnet18_cifar10_mixed_int.json index d0d210acc78..15d98900604 100644 --- a/tests/data/configs/hawq/resnet18_cifar10_mixed_int.json +++ b/tests/data/configs/hawq/resnet18_cifar10_mixed_int.json @@ -1,6 +1,5 @@ { "model": "resnet18", - "dataset": "CIFAR10", "input_info": { "sample_size": [ 2, diff --git a/tests/data/configs/hawq/resnet18_cifar10_mixed_int_staged.json b/tests/data/configs/hawq/resnet18_cifar10_mixed_int_staged.json deleted file mode 100644 index e05c64f4e51..00000000000 --- a/tests/data/configs/hawq/resnet18_cifar10_mixed_int_staged.json +++ /dev/null @@ -1,37 +0,0 @@ -{ - "model": "resnet18", - "dataset": "CIFAR10", - "input_info": { - "sample_size": [ - 2, - 3, - 32, - 32 - ] - }, - "num_classes": 10, - "pretrained": false, - "target_device": "VPU", - "compression": [ - { - "algorithm": "quantization", - "initializer": { - "precision": { - "type": "hawq", - "num_data_points": 2, - "iter_number": 1 - }, - "batchnorm_adaptation": { - "num_bn_adaptation_samples": 2, - "num_bn_forget_samples": 1 - }, - "range": { - "num_init_samples": 1 - } - }, - "params": { - "activations_quant_start_epoch": 0 - } - } - ] -} diff --git a/tests/data/reference_graphs/quantized/autoq/inception_v3_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based__with_ignored_scopes.dot b/tests/data/reference_graphs/quantized/autoq/inception_v3_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based__with_ignored_scopes.dot new file mode 100644 index 00000000000..52b56a40d4e --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/inception_v3_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based__with_ignored_scopes.dot @@ -0,0 +1,1080 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=3, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"4 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm" [id=4, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"5 Inception3/BasicConv2d[Conv2d_1a_3x3]/RELU" [id=5, label=RELU, scope="Inception3/BasicConv2d[Conv2d_1a_3x3]", style=filled, type=RELU]; +"6 Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#2", scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d" [id=7, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]", style=filled, type=conv2d]; +"8 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm" [id=8, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"9 Inception3/BasicConv2d[Conv2d_2a_3x3]/RELU" [id=9, label=RELU, scope="Inception3/BasicConv2d[Conv2d_2a_3x3]", style=filled, type=RELU]; +"10 Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=10, label="8_bit__AFQ_#3", scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"11 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=11, label="8_bit__WFQ_#3", scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"12 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=12, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"13 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm" [id=13, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"14 Inception3/BasicConv2d[Conv2d_2b_3x3]/RELU" [id=14, label=RELU, scope="Inception3/BasicConv2d[Conv2d_2b_3x3]", style=filled, type=RELU]; +"15 Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=15, label="4_bit__AFQ_#4", scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"16 Inception3/MaxPool2d[maxpool1]/max_pool2d" [id=16, label=max_pool2d, scope="Inception3/MaxPool2d[maxpool1]", style=filled, type=max_pool2d]; +"17 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=17, label="4_bit__WFQ_#4", scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"18 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=18, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"19 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm" [id=19, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"20 Inception3/BasicConv2d[Conv2d_3b_1x1]/RELU" [id=20, label=RELU, scope="Inception3/BasicConv2d[Conv2d_3b_1x1]", style=filled, type=RELU]; +"21 Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=21, label="8_bit__AFQ_#5", scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"22 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=22, label="8_bit__WFQ_#5", scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"23 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=23, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"24 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm" [id=24, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"25 Inception3/BasicConv2d[Conv2d_4a_3x3]/RELU" [id=25, label=RELU, scope="Inception3/BasicConv2d[Conv2d_4a_3x3]", style=filled, type=RELU]; +"26 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=26, label="8_bit__AFQ_#6", scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"27 Inception3/MaxPool2d[maxpool2]/max_pool2d" [id=27, label=max_pool2d, scope="Inception3/MaxPool2d[maxpool2]", style=filled, type=max_pool2d]; +"28 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=28, label="4_bit__WFQ_#6", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"29 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=29, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=30, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"31 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/RELU" [id=31, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"32 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=32, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"33 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=33, label="8_bit__WFQ_#6", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"34 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=34, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" [id=35, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"36 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/RELU" [id=36, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]", style=filled, type=RELU]; +"37 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=37, label="4_bit__AFQ_#10", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"38 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=38, label="4_bit__WFQ_#10", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"39 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=39, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" [id=40, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"41 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/RELU" [id=41, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]", style=filled, type=RELU]; +"42 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=42, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"43 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=43, label="8_bit__WFQ_#6", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"44 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=44, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=45, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"46 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/RELU" [id=46, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"47 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=47, label="8_bit__AFQ_#8", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=48, label="4_bit__WFQ_#8", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=49, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=50, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/RELU" [id=51, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=52, label="4_bit__AFQ_#9", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=53, label="4_bit__WFQ_#9", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=54, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=55, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/RELU" [id=56, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=57, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"58 Inception3/InceptionA[Mixed_5b]/avg_pool2d" [id=58, label=avg_pool2d, scope="Inception3/InceptionA[Mixed_5b]", style=filled, type=avg_pool2d]; +"59 Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=59, label="4_bit__AFQ_#11", scope="Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=60, label="8_bit__WFQ_#11", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=61, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=62, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/RELU" [id=63, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=64, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"65 Inception3/InceptionA[Mixed_5b]/cat" [id=65, label=cat, scope="Inception3/InceptionA[Mixed_5b]", style=filled, type=cat]; +"66 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=66, label="8_bit__WFQ_#7", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"67 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=67, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=68, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"69 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/RELU" [id=69, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"70 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=70, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"71 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=71, label="4_bit__WFQ_#7", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"72 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=72, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" [id=73, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"74 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/RELU" [id=74, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]", style=filled, type=RELU]; +"75 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=75, label="8_bit__AFQ_#15", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=76, label="4_bit__WFQ_#15", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=77, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" [id=78, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"79 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/RELU" [id=79, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]", style=filled, type=RELU]; +"80 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=80, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"81 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=81, label="8_bit__WFQ_#7", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"82 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=82, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=83, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"84 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/RELU" [id=84, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"85 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=85, label="8_bit__AFQ_#13", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=86, label="8_bit__WFQ_#13", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=87, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=88, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/RELU" [id=89, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=90, label="4_bit__AFQ_#14", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=91, label="4_bit__WFQ_#14", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=92, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=93, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/RELU" [id=94, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=95, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"96 Inception3/InceptionA[Mixed_5c]/avg_pool2d" [id=96, label=avg_pool2d, scope="Inception3/InceptionA[Mixed_5c]", style=filled, type=avg_pool2d]; +"97 Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=97, label="4_bit__AFQ_#16", scope="Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"98 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=98, label="4_bit__WFQ_#16", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=99, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=100, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/RELU" [id=101, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=102, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"103 Inception3/InceptionA[Mixed_5c]/cat" [id=103, label=cat, scope="Inception3/InceptionA[Mixed_5c]", style=filled, type=cat]; +"104 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=104, label="8_bit__WFQ_#12", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"105 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=105, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=106, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"107 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/RELU" [id=107, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"108 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=108, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"109 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=109, label="8_bit__WFQ_#12", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"110 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=110, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" [id=111, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"112 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/RELU" [id=112, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]", style=filled, type=RELU]; +"113 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=113, label="4_bit__AFQ_#20", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"114 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=114, label="8_bit__WFQ_#20", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"115 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=115, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" [id=116, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"117 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/RELU" [id=117, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]", style=filled, type=RELU]; +"118 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=118, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"119 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=119, label="4_bit__WFQ_#12", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"120 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=120, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=121, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"122 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/RELU" [id=122, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"123 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=123, label="8_bit__AFQ_#18", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=124, label="8_bit__WFQ_#18", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=125, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=126, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/RELU" [id=127, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=128, label="4_bit__AFQ_#19", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=129, label="8_bit__WFQ_#19", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=130, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=131, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/RELU" [id=132, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=133, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"134 Inception3/InceptionA[Mixed_5d]/avg_pool2d" [id=134, label=avg_pool2d, scope="Inception3/InceptionA[Mixed_5d]", style=filled, type=avg_pool2d]; +"135 Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=135, label="4_bit__AFQ_#21", scope="Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"136 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=136, label="8_bit__WFQ_#21", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=137, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=138, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/RELU" [id=139, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=140, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"141 Inception3/InceptionA[Mixed_5d]/cat" [id=141, label=cat, scope="Inception3/InceptionA[Mixed_5d]", style=filled, type=cat]; +"142 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=142, label="4_bit__WFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"143 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=143, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm" [id=144, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"145 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/RELU" [id=145, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]", style=filled, type=RELU]; +"146 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=146, label="8_bit__AFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"147 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=147, label="8_bit__WFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"148 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=148, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=149, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"150 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/RELU" [id=150, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"151 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=151, label="8_bit__AFQ_#22", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"152 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=152, label="4_bit__WFQ_#22", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"153 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=153, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=154, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"155 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/RELU" [id=155, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"156 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=156, label="8_bit__AFQ_#23", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"157 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=157, label="4_bit__WFQ_#23", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"158 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=158, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=159, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"160 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/RELU" [id=160, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"161 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=161, label="8_bit__AFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"162 Inception3/InceptionB[Mixed_6a]/max_pool2d" [id=162, label=max_pool2d, scope="Inception3/InceptionB[Mixed_6a]", style=filled, type=max_pool2d]; +"163 Inception3/InceptionB[Mixed_6a]/cat" [id=163, label=cat, scope="Inception3/InceptionB[Mixed_6a]", style=filled, type=cat]; +"164 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=164, label="4_bit__WFQ_#17", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"165 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=165, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=166, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"167 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/RELU" [id=167, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"168 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=168, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"169 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=169, label="4_bit__WFQ_#17", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"170 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=170, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=171, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"172 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/RELU" [id=172, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"173 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=173, label="8_bit__AFQ_#25", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"174 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=174, label="8_bit__WFQ_#25", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"175 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=175, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=176, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"177 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/RELU" [id=177, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"178 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=178, label="8_bit__AFQ_#26", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"179 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=179, label="8_bit__WFQ_#26", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"180 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=180, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=181, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"182 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/RELU" [id=182, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"183 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=183, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=184, label="8_bit__WFQ_#17", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=185, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=186, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/RELU" [id=187, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=188, label="4_bit__AFQ_#27", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=189, label="8_bit__WFQ_#27", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=190, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=191, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/RELU" [id=192, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=193, label="4_bit__AFQ_#28", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=194, label="4_bit__WFQ_#28", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=195, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=196, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/RELU" [id=197, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=198, label="8_bit__AFQ_#29", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=199, label="4_bit__WFQ_#29", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=200, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=201, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/RELU" [id=202, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=203, label="8_bit__AFQ_#30", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=204, label="8_bit__WFQ_#30", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=205, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=206, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/RELU" [id=207, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=208, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"209 Inception3/InceptionC[Mixed_6b]/avg_pool2d" [id=209, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6b]", style=filled, type=avg_pool2d]; +"210 Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=210, label="4_bit__AFQ_#31", scope="Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"211 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=211, label="8_bit__WFQ_#31", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=212, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=213, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/RELU" [id=214, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=215, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"216 Inception3/InceptionC[Mixed_6b]/cat" [id=216, label=cat, scope="Inception3/InceptionC[Mixed_6b]", style=filled, type=cat]; +"217 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=217, label="4_bit__WFQ_#24", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"218 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=218, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=219, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"220 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/RELU" [id=220, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"221 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=221, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"222 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=222, label="8_bit__WFQ_#24", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"223 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=223, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=224, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"225 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/RELU" [id=225, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"226 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=226, label="4_bit__AFQ_#33", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"227 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=227, label="8_bit__WFQ_#33", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"228 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=228, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=229, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"230 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/RELU" [id=230, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"231 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=231, label="8_bit__AFQ_#34", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"232 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=232, label="8_bit__WFQ_#34", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"233 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=233, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=234, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"235 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/RELU" [id=235, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"236 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=236, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=237, label="8_bit__WFQ_#24", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=238, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=239, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/RELU" [id=240, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=241, label="8_bit__AFQ_#35", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=242, label="8_bit__WFQ_#35", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=243, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=244, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/RELU" [id=245, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=246, label="8_bit__AFQ_#36", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=247, label="8_bit__WFQ_#36", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=248, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=249, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/RELU" [id=250, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=251, label="4_bit__AFQ_#37", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=252, label="4_bit__WFQ_#37", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=253, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=254, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/RELU" [id=255, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=256, label="4_bit__AFQ_#38", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=257, label="8_bit__WFQ_#38", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=258, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=259, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/RELU" [id=260, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=261, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"262 Inception3/InceptionC[Mixed_6c]/avg_pool2d" [id=262, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6c]", style=filled, type=avg_pool2d]; +"263 Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=263, label="8_bit__AFQ_#39", scope="Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"264 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=264, label="8_bit__WFQ_#39", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=265, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=266, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/RELU" [id=267, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=268, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"269 Inception3/InceptionC[Mixed_6c]/cat" [id=269, label=cat, scope="Inception3/InceptionC[Mixed_6c]", style=filled, type=cat]; +"270 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=270, label="8_bit__WFQ_#32", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"271 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=271, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=272, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"273 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/RELU" [id=273, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"274 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=274, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"275 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=275, label="4_bit__WFQ_#32", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"276 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=276, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=277, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"278 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/RELU" [id=278, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"279 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=279, label="4_bit__AFQ_#41", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"280 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=280, label="8_bit__WFQ_#41", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"281 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=281, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=282, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"283 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/RELU" [id=283, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"284 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=284, label="4_bit__AFQ_#42", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"285 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=285, label="8_bit__WFQ_#42", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"286 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=286, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=287, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"288 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/RELU" [id=288, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"289 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=289, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=290, label="8_bit__WFQ_#32", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=291, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=292, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/RELU" [id=293, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=294, label="4_bit__AFQ_#43", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=295, label="4_bit__WFQ_#43", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=296, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=297, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/RELU" [id=298, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=299, label="4_bit__AFQ_#44", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=300, label="4_bit__WFQ_#44", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=301, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=302, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/RELU" [id=303, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=304, label="4_bit__AFQ_#45", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=305, label="8_bit__WFQ_#45", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=306, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=307, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/RELU" [id=308, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=309, label="8_bit__AFQ_#46", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=310, label="4_bit__WFQ_#46", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=311, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=312, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/RELU" [id=313, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=314, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"315 Inception3/InceptionC[Mixed_6d]/avg_pool2d" [id=315, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6d]", style=filled, type=avg_pool2d]; +"316 Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=316, label="8_bit__AFQ_#47", scope="Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"317 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=317, label="8_bit__WFQ_#47", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=318, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=319, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/RELU" [id=320, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=321, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"322 Inception3/InceptionC[Mixed_6d]/cat" [id=322, label=cat, scope="Inception3/InceptionC[Mixed_6d]", style=filled, type=cat]; +"323 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=323, label="4_bit__WFQ_#40", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"324 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=324, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=325, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"326 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/RELU" [id=326, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"327 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=327, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"328 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=328, label="4_bit__WFQ_#40", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"329 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=329, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=330, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"331 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/RELU" [id=331, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"332 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=332, label="8_bit__AFQ_#49", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"333 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=333, label="4_bit__WFQ_#49", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"334 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=334, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=335, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"336 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/RELU" [id=336, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"337 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=337, label="8_bit__AFQ_#50", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"338 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=338, label="8_bit__WFQ_#50", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"339 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=339, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=340, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"341 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/RELU" [id=341, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"342 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=342, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=343, label="4_bit__WFQ_#40", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=344, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=345, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/RELU" [id=346, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=347, label="8_bit__AFQ_#51", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=348, label="4_bit__WFQ_#51", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=349, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=350, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/RELU" [id=351, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=352, label="4_bit__AFQ_#52", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=353, label="4_bit__WFQ_#52", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=354, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=355, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/RELU" [id=356, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=357, label="8_bit__AFQ_#53", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=358, label="4_bit__WFQ_#53", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=359, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=360, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/RELU" [id=361, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=362, label="4_bit__AFQ_#54", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=363, label="8_bit__WFQ_#54", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=364, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=365, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/RELU" [id=366, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=367, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"368 Inception3/InceptionC[Mixed_6e]/avg_pool2d" [id=368, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6e]", style=filled, type=avg_pool2d]; +"369 Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=369, label="4_bit__AFQ_#55", scope="Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"370 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=370, label="4_bit__WFQ_#55", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=371, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=372, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/RELU" [id=373, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=374, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"375 Inception3/InceptionC[Mixed_6e]/cat" [id=375, label=cat, scope="Inception3/InceptionC[Mixed_6e]", style=filled, type=cat]; +"376 Inception3/InceptionAux[AuxLogits]/avg_pool2d" [id=376, label=avg_pool2d, scope="Inception3/InceptionAux[AuxLogits]", style=filled, type=avg_pool2d]; +"377 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]/conv2d" [id=377, label=conv2d, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]", style=filled, type=conv2d]; +"378 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]/batch_norm" [id=378, label=batch_norm, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"379 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/RELU" [id=379, label=RELU, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]", style=filled, type=RELU]; +"380 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]/conv2d" [id=380, label=conv2d, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]", style=filled, type=conv2d]; +"381 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]/batch_norm" [id=381, label=batch_norm, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"382 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/RELU" [id=382, label=RELU, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]", style=filled, type=RELU]; +"383 Inception3/InceptionAux[AuxLogits]/adaptive_avg_pool2d" [id=383, label=adaptive_avg_pool2d, scope="Inception3/InceptionAux[AuxLogits]", style=filled, type=adaptive_avg_pool2d]; +"384 Inception3/InceptionAux[AuxLogits]/Linear[fc]/linear" [id=384, label=linear, scope="Inception3/InceptionAux[AuxLogits]/Linear[fc]", style=filled, type=linear]; +"385 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=385, label="4_bit__WFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"386 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=386, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" [id=387, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"388 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/RELU" [id=388, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]", style=filled, type=RELU]; +"389 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=389, label="8_bit__AFQ_#56", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"390 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=390, label="8_bit__WFQ_#56", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"391 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=391, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm" [id=392, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"393 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/RELU" [id=393, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]", style=filled, type=RELU]; +"394 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=394, label="8_bit__AFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"395 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=395, label="4_bit__WFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=396, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm" [id=397, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/RELU" [id=398, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]", style=filled, type=RELU]; +"399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=399, label="8_bit__AFQ_#57", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=400, label="8_bit__WFQ_#57", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=401, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm" [id=402, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/RELU" [id=403, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]", style=filled, type=RELU]; +"404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=404, label="8_bit__AFQ_#58", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=405, label="8_bit__WFQ_#58", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=406, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm" [id=407, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/RELU" [id=408, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]", style=filled, type=RELU]; +"409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=409, label="8_bit__AFQ_#59", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=410, label="4_bit__WFQ_#59", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=411, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm" [id=412, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/RELU" [id=413, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]", style=filled, type=RELU]; +"414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize" [color=green, id=414, label="8_bit__AFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"415 Inception3/InceptionD[Mixed_7a]/max_pool2d" [id=415, label=max_pool2d, scope="Inception3/InceptionD[Mixed_7a]", style=filled, type=max_pool2d]; +"416 Inception3/InceptionD[Mixed_7a]/cat" [id=416, label=cat, scope="Inception3/InceptionD[Mixed_7a]", style=filled, type=cat]; +"417 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=417, label="4_bit__WFQ_#48", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"418 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=418, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=419, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"420 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/RELU" [id=420, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"421 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=421, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"422 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=422, label="4_bit__WFQ_#48", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"423 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=423, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" [id=424, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"425 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/RELU" [id=425, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]", style=filled, type=RELU]; +"426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=426, label="8_bit__AFQ_#61", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"427 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=427, label="4_bit__WFQ_#61", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=428, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" [id=429, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/RELU" [id=430, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]", style=filled, type=RELU]; +"431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=431, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=432, label="4_bit__WFQ_#61", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=433, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" [id=434, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/RELU" [id=435, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]", style=filled, type=RELU]; +"436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=436, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"437 Inception3/InceptionE[Mixed_7b]/cat" [id=437, label=cat, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=cat]; +"438 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=438, label="2_bit__WFQ_#48", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=439, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=440, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/RELU" [id=441, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=442, label="8_bit__AFQ_#62", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=443, label="4_bit__WFQ_#62", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=444, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=445, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/RELU" [id=446, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=447, label="8_bit__AFQ_#63", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"448 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=448, label="4_bit__WFQ_#63", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=449, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" [id=450, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/RELU" [id=451, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]", style=filled, type=RELU]; +"452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=452, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=453, label="4_bit__WFQ_#63", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=454, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" [id=455, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/RELU" [id=456, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]", style=filled, type=RELU]; +"457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=457, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"458 Inception3/InceptionE[Mixed_7b]/cat" [id=458, label=cat, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=cat]; +"459 Inception3/InceptionE[Mixed_7b]/avg_pool2d" [id=459, label=avg_pool2d, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=avg_pool2d]; +"460 Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=460, label="4_bit__AFQ_#64", scope="Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"461 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=461, label="4_bit__WFQ_#64", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=462, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=463, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/RELU" [id=464, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=465, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"466 Inception3/InceptionE[Mixed_7b]/cat" [id=466, label=cat, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=cat]; +"467 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=467, label="4_bit__WFQ_#60", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"468 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=468, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=469, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"470 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/RELU" [id=470, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"471 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=471, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"472 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=472, label="4_bit__WFQ_#60", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"473 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=473, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" [id=474, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"475 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/RELU" [id=475, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]", style=filled, type=RELU]; +"476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=476, label="4_bit__AFQ_#66", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"477 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=477, label="2_bit__WFQ_#66", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=478, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" [id=479, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/RELU" [id=480, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]", style=filled, type=RELU]; +"481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=481, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=482, label="4_bit__WFQ_#66", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=483, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" [id=484, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/RELU" [id=485, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]", style=filled, type=RELU]; +"486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=486, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"487 Inception3/InceptionE[Mixed_7c]/cat" [id=487, label=cat, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=cat]; +"488 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=488, label="4_bit__WFQ_#60", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=489, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=490, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/RELU" [id=491, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=492, label="4_bit__AFQ_#67", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=493, label="2_bit__WFQ_#67", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=494, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=495, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/RELU" [id=496, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=497, label="4_bit__AFQ_#68", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"498 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=498, label="4_bit__WFQ_#68", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=499, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" [id=500, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/RELU" [id=501, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]", style=filled, type=RELU]; +"502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=502, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=503, label="2_bit__WFQ_#68", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=504, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" [id=505, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/RELU" [id=506, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]", style=filled, type=RELU]; +"507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=507, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"508 Inception3/InceptionE[Mixed_7c]/cat" [id=508, label=cat, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=cat]; +"509 Inception3/InceptionE[Mixed_7c]/avg_pool2d" [id=509, label=avg_pool2d, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=avg_pool2d]; +"510 Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=510, label="4_bit__AFQ_#69", scope="Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"511 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=511, label="2_bit__WFQ_#69", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=512, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=513, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/RELU" [id=514, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=515, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"516 Inception3/InceptionE[Mixed_7c]/cat" [id=516, label=cat, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=cat]; +"517 Inception3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=517, label=adaptive_avg_pool2d, scope="Inception3/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"518 Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=518, label="4_bit__AFQ_#1", scope="Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"519 Inception3/Dropout[dropout]/dropout" [id=519, label=dropout, scope="Inception3/Dropout[dropout]", style=filled, type=dropout]; +"520 Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=520, label="4_bit__WFQ_#1", scope="Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"521 Inception3/NNCFLinear[fc]/linear" [id=521, label=linear, scope="Inception3/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d"; +"2 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d"; +"3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d" -> "4 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm"; +"4 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm" -> "5 Inception3/BasicConv2d[Conv2d_1a_3x3]/RELU"; +"5 Inception3/BasicConv2d[Conv2d_1a_3x3]/RELU" -> "6 Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer/asymmetric_quantize"; +"6 Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer/asymmetric_quantize" -> "7 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d"; +"7 Inception3/BasicConv2d[Conv2d_2a_3x3]/Conv2d[conv]/conv2d" -> "8 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm"; +"8 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm" -> "9 Inception3/BasicConv2d[Conv2d_2a_3x3]/RELU"; +"9 Inception3/BasicConv2d[Conv2d_2a_3x3]/RELU" -> "10 Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer/asymmetric_quantize"; +"10 Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer/asymmetric_quantize" -> "12 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d"; +"11 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "12 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d"; +"12 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d" -> "13 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm"; +"13 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm" -> "14 Inception3/BasicConv2d[Conv2d_2b_3x3]/RELU"; +"14 Inception3/BasicConv2d[Conv2d_2b_3x3]/RELU" -> "15 Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer/asymmetric_quantize"; +"15 Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer/asymmetric_quantize" -> "16 Inception3/MaxPool2d[maxpool1]/max_pool2d"; +"16 Inception3/MaxPool2d[maxpool1]/max_pool2d" -> "18 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d"; +"17 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "18 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d"; +"18 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d" -> "19 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm"; +"19 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm" -> "20 Inception3/BasicConv2d[Conv2d_3b_1x1]/RELU"; +"20 Inception3/BasicConv2d[Conv2d_3b_1x1]/RELU" -> "21 Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer/asymmetric_quantize"; +"21 Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer/asymmetric_quantize" -> "23 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d"; +"22 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "23 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d"; +"23 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d" -> "24 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm"; +"24 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm" -> "25 Inception3/BasicConv2d[Conv2d_4a_3x3]/RELU"; +"25 Inception3/BasicConv2d[Conv2d_4a_3x3]/RELU" -> "26 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize"; +"26 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize" -> "27 Inception3/MaxPool2d[maxpool2]/max_pool2d"; +"27 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "29 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"27 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "34 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"27 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "44 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"27 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "58 Inception3/InceptionA[Mixed_5b]/avg_pool2d"; +"28 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "29 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"29 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "31 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/RELU"; +"31 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/RELU" -> "32 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"32 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "65 Inception3/InceptionA[Mixed_5b]/cat"; +"33 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "34 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"34 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" -> "35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm"; +"35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" -> "36 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/RELU"; +"36 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/RELU" -> "37 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize"; +"37 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" -> "39 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"38 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "39 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"39 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" -> "40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm"; +"40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" -> "41 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/RELU"; +"41 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/RELU" -> "42 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize"; +"42 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" -> "65 Inception3/InceptionA[Mixed_5b]/cat"; +"43 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "44 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"44 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "46 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/RELU"; +"46 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/RELU" -> "47 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"47 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/RELU"; +"51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/RELU" -> "52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/RELU"; +"56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/RELU" -> "57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "65 Inception3/InceptionA[Mixed_5b]/cat"; +"58 Inception3/InceptionA[Mixed_5b]/avg_pool2d" -> "59 Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer/asymmetric_quantize"; +"59 Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer/asymmetric_quantize" -> "61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"60 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/RELU"; +"63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/RELU" -> "64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "65 Inception3/InceptionA[Mixed_5b]/cat"; +"65 Inception3/InceptionA[Mixed_5b]/cat" -> "67 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"65 Inception3/InceptionA[Mixed_5b]/cat" -> "72 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"65 Inception3/InceptionA[Mixed_5b]/cat" -> "82 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"65 Inception3/InceptionA[Mixed_5b]/cat" -> "96 Inception3/InceptionA[Mixed_5c]/avg_pool2d"; +"66 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "67 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"67 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "69 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/RELU"; +"69 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/RELU" -> "70 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"70 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "103 Inception3/InceptionA[Mixed_5c]/cat"; +"71 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "72 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"72 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" -> "73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm"; +"73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" -> "74 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/RELU"; +"74 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/RELU" -> "75 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize"; +"75 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" -> "77 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"76 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"77 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" -> "78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm"; +"78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" -> "79 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/RELU"; +"79 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/RELU" -> "80 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize"; +"80 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" -> "103 Inception3/InceptionA[Mixed_5c]/cat"; +"81 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "82 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"82 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "84 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/RELU"; +"84 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/RELU" -> "85 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"85 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/RELU"; +"89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/RELU" -> "90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/RELU"; +"94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/RELU" -> "95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "103 Inception3/InceptionA[Mixed_5c]/cat"; +"96 Inception3/InceptionA[Mixed_5c]/avg_pool2d" -> "97 Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer/asymmetric_quantize"; +"97 Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer/asymmetric_quantize" -> "99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"98 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/RELU"; +"101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/RELU" -> "102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "103 Inception3/InceptionA[Mixed_5c]/cat"; +"103 Inception3/InceptionA[Mixed_5c]/cat" -> "105 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"103 Inception3/InceptionA[Mixed_5c]/cat" -> "110 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"103 Inception3/InceptionA[Mixed_5c]/cat" -> "120 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"103 Inception3/InceptionA[Mixed_5c]/cat" -> "134 Inception3/InceptionA[Mixed_5d]/avg_pool2d"; +"104 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "105 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"105 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "107 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/RELU"; +"107 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/RELU" -> "108 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"108 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "141 Inception3/InceptionA[Mixed_5d]/cat"; +"109 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "110 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"110 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" -> "111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm"; +"111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" -> "112 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/RELU"; +"112 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/RELU" -> "113 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize"; +"113 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" -> "115 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"114 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "115 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"115 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" -> "116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm"; +"116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" -> "117 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/RELU"; +"117 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/RELU" -> "118 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize"; +"118 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" -> "141 Inception3/InceptionA[Mixed_5d]/cat"; +"119 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "120 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"120 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "122 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/RELU"; +"122 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/RELU" -> "123 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"123 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/RELU"; +"127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/RELU" -> "128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/RELU"; +"132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/RELU" -> "133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "141 Inception3/InceptionA[Mixed_5d]/cat"; +"134 Inception3/InceptionA[Mixed_5d]/avg_pool2d" -> "135 Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer/asymmetric_quantize"; +"135 Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer/asymmetric_quantize" -> "137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"136 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/RELU"; +"139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/RELU" -> "140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "141 Inception3/InceptionA[Mixed_5d]/cat"; +"141 Inception3/InceptionA[Mixed_5d]/cat" -> "143 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d"; +"141 Inception3/InceptionA[Mixed_5d]/cat" -> "148 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"141 Inception3/InceptionA[Mixed_5d]/cat" -> "162 Inception3/InceptionB[Mixed_6a]/max_pool2d"; +"142 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "143 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d"; +"143 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d" -> "144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm"; +"144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm" -> "145 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/RELU"; +"145 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/RELU" -> "146 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize"; +"146 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize" -> "163 Inception3/InceptionB[Mixed_6a]/cat"; +"147 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "148 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"148 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "150 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/RELU"; +"150 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/RELU" -> "151 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"151 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "153 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"152 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "153 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"153 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "155 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/RELU"; +"155 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/RELU" -> "156 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"156 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "158 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"157 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "158 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"158 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "160 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/RELU"; +"160 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/RELU" -> "161 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"161 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "163 Inception3/InceptionB[Mixed_6a]/cat"; +"162 Inception3/InceptionB[Mixed_6a]/max_pool2d" -> "163 Inception3/InceptionB[Mixed_6a]/cat"; +"163 Inception3/InceptionB[Mixed_6a]/cat" -> "165 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"163 Inception3/InceptionB[Mixed_6a]/cat" -> "170 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"163 Inception3/InceptionB[Mixed_6a]/cat" -> "185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"163 Inception3/InceptionB[Mixed_6a]/cat" -> "209 Inception3/InceptionC[Mixed_6b]/avg_pool2d"; +"164 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "165 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"165 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "167 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/RELU"; +"167 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/RELU" -> "168 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"168 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "216 Inception3/InceptionC[Mixed_6b]/cat"; +"169 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "170 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"170 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "172 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/RELU"; +"172 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/RELU" -> "173 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"173 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "175 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"174 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "175 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"175 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "177 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/RELU"; +"177 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/RELU" -> "178 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"178 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "180 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"179 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "180 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"180 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "182 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/RELU"; +"182 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/RELU" -> "183 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"183 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "216 Inception3/InceptionC[Mixed_6b]/cat"; +"184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/RELU"; +"187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/RELU" -> "188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/RELU"; +"192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/RELU" -> "193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/RELU"; +"197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/RELU" -> "198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/RELU"; +"202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/RELU" -> "203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/RELU"; +"207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/RELU" -> "208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "216 Inception3/InceptionC[Mixed_6b]/cat"; +"209 Inception3/InceptionC[Mixed_6b]/avg_pool2d" -> "210 Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer/asymmetric_quantize"; +"210 Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer/asymmetric_quantize" -> "212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"211 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/RELU"; +"214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/RELU" -> "215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "216 Inception3/InceptionC[Mixed_6b]/cat"; +"216 Inception3/InceptionC[Mixed_6b]/cat" -> "218 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"216 Inception3/InceptionC[Mixed_6b]/cat" -> "223 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"216 Inception3/InceptionC[Mixed_6b]/cat" -> "238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"216 Inception3/InceptionC[Mixed_6b]/cat" -> "262 Inception3/InceptionC[Mixed_6c]/avg_pool2d"; +"217 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "218 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"218 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "220 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/RELU"; +"220 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/RELU" -> "221 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"221 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "269 Inception3/InceptionC[Mixed_6c]/cat"; +"222 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "223 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"223 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "225 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/RELU"; +"225 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/RELU" -> "226 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"226 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "228 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"227 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "228 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"228 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "230 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/RELU"; +"230 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/RELU" -> "231 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"231 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "233 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"232 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "233 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"233 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "235 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/RELU"; +"235 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/RELU" -> "236 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"236 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "269 Inception3/InceptionC[Mixed_6c]/cat"; +"237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/RELU"; +"240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/RELU" -> "241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/RELU"; +"245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/RELU" -> "246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/RELU"; +"250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/RELU" -> "251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/RELU"; +"255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/RELU" -> "256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/RELU"; +"260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/RELU" -> "261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "269 Inception3/InceptionC[Mixed_6c]/cat"; +"262 Inception3/InceptionC[Mixed_6c]/avg_pool2d" -> "263 Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer/asymmetric_quantize"; +"263 Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer/asymmetric_quantize" -> "265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"264 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/RELU"; +"267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/RELU" -> "268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "269 Inception3/InceptionC[Mixed_6c]/cat"; +"269 Inception3/InceptionC[Mixed_6c]/cat" -> "271 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"269 Inception3/InceptionC[Mixed_6c]/cat" -> "276 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"269 Inception3/InceptionC[Mixed_6c]/cat" -> "291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"269 Inception3/InceptionC[Mixed_6c]/cat" -> "315 Inception3/InceptionC[Mixed_6d]/avg_pool2d"; +"270 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "271 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"271 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "273 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/RELU"; +"273 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/RELU" -> "274 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"274 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "322 Inception3/InceptionC[Mixed_6d]/cat"; +"275 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "276 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"276 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "278 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/RELU"; +"278 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/RELU" -> "279 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"279 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "281 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"280 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "281 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"281 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "283 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/RELU"; +"283 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/RELU" -> "284 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"284 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "286 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"285 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "286 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"286 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "288 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/RELU"; +"288 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/RELU" -> "289 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"289 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "322 Inception3/InceptionC[Mixed_6d]/cat"; +"290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/RELU"; +"293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/RELU" -> "294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/RELU"; +"298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/RELU" -> "299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/RELU"; +"303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/RELU" -> "304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/RELU"; +"308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/RELU" -> "309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/RELU"; +"313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/RELU" -> "314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "322 Inception3/InceptionC[Mixed_6d]/cat"; +"315 Inception3/InceptionC[Mixed_6d]/avg_pool2d" -> "316 Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer/asymmetric_quantize"; +"316 Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer/asymmetric_quantize" -> "318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"317 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/RELU"; +"320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/RELU" -> "321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "322 Inception3/InceptionC[Mixed_6d]/cat"; +"322 Inception3/InceptionC[Mixed_6d]/cat" -> "324 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"322 Inception3/InceptionC[Mixed_6d]/cat" -> "329 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"322 Inception3/InceptionC[Mixed_6d]/cat" -> "344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"322 Inception3/InceptionC[Mixed_6d]/cat" -> "368 Inception3/InceptionC[Mixed_6e]/avg_pool2d"; +"323 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "324 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"324 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "326 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/RELU"; +"326 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/RELU" -> "327 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"327 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "375 Inception3/InceptionC[Mixed_6e]/cat"; +"328 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "329 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"329 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "331 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/RELU"; +"331 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/RELU" -> "332 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"332 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "334 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"333 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "334 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"334 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "336 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/RELU"; +"336 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/RELU" -> "337 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"337 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "339 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"338 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "339 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"339 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "341 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/RELU"; +"341 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/RELU" -> "342 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"342 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "375 Inception3/InceptionC[Mixed_6e]/cat"; +"343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/RELU"; +"346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/RELU" -> "347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/RELU"; +"351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/RELU" -> "352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/RELU"; +"356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/RELU" -> "357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/RELU"; +"361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/RELU" -> "362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/RELU"; +"366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/RELU" -> "367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "375 Inception3/InceptionC[Mixed_6e]/cat"; +"368 Inception3/InceptionC[Mixed_6e]/avg_pool2d" -> "369 Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer/asymmetric_quantize"; +"369 Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer/asymmetric_quantize" -> "371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"370 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/RELU"; +"373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/RELU" -> "374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "375 Inception3/InceptionC[Mixed_6e]/cat"; +"375 Inception3/InceptionC[Mixed_6e]/cat" -> "376 Inception3/InceptionAux[AuxLogits]/avg_pool2d"; +"375 Inception3/InceptionC[Mixed_6e]/cat" -> "386 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"375 Inception3/InceptionC[Mixed_6e]/cat" -> "396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d"; +"375 Inception3/InceptionC[Mixed_6e]/cat" -> "415 Inception3/InceptionD[Mixed_7a]/max_pool2d"; +"376 Inception3/InceptionAux[AuxLogits]/avg_pool2d" -> "377 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]/conv2d"; +"377 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]/conv2d" -> "378 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]/batch_norm"; +"378 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]/batch_norm" -> "379 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/RELU"; +"379 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/RELU" -> "380 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]/conv2d"; +"380 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]/conv2d" -> "381 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]/batch_norm"; +"381 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]/batch_norm" -> "382 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/RELU"; +"382 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/RELU" -> "383 Inception3/InceptionAux[AuxLogits]/adaptive_avg_pool2d"; +"383 Inception3/InceptionAux[AuxLogits]/adaptive_avg_pool2d" -> "384 Inception3/InceptionAux[AuxLogits]/Linear[fc]/linear"; +"385 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "386 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"386 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" -> "387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm"; +"387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" -> "388 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/RELU"; +"388 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/RELU" -> "389 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"389 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "391 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d"; +"390 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "391 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d"; +"391 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d" -> "392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm"; +"392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm" -> "393 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/RELU"; +"393 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/RELU" -> "394 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize"; +"394 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize" -> "416 Inception3/InceptionD[Mixed_7a]/cat"; +"395 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d"; +"396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d" -> "397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm"; +"397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm" -> "398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/RELU"; +"398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/RELU" -> "399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d"; +"400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d"; +"401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d" -> "402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm"; +"402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm" -> "403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/RELU"; +"403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/RELU" -> "404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer/asymmetric_quantize"; +"404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer/asymmetric_quantize" -> "406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d"; +"405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d"; +"406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d" -> "407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm"; +"407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm" -> "408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/RELU"; +"408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/RELU" -> "409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer/asymmetric_quantize"; +"409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer/asymmetric_quantize" -> "411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d"; +"410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d"; +"411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d" -> "412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm"; +"412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm" -> "413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/RELU"; +"413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/RELU" -> "414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize"; +"414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize" -> "416 Inception3/InceptionD[Mixed_7a]/cat"; +"415 Inception3/InceptionD[Mixed_7a]/max_pool2d" -> "416 Inception3/InceptionD[Mixed_7a]/cat"; +"416 Inception3/InceptionD[Mixed_7a]/cat" -> "418 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"416 Inception3/InceptionD[Mixed_7a]/cat" -> "423 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"416 Inception3/InceptionD[Mixed_7a]/cat" -> "439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"416 Inception3/InceptionD[Mixed_7a]/cat" -> "459 Inception3/InceptionE[Mixed_7b]/avg_pool2d"; +"417 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "418 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"418 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "420 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/RELU"; +"420 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/RELU" -> "421 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"421 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "466 Inception3/InceptionE[Mixed_7b]/cat"; +"422 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "423 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"423 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" -> "424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm"; +"424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" -> "425 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/RELU"; +"425 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/RELU" -> "426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"427 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" -> "429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm"; +"429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" -> "430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/RELU"; +"430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/RELU" -> "431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize"; +"431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" -> "437 Inception3/InceptionE[Mixed_7b]/cat"; +"432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" -> "434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm"; +"434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" -> "435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/RELU"; +"435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/RELU" -> "436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize"; +"436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" -> "437 Inception3/InceptionE[Mixed_7b]/cat"; +"437 Inception3/InceptionE[Mixed_7b]/cat" -> "466 Inception3/InceptionE[Mixed_7b]/cat"; +"438 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/RELU"; +"441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/RELU" -> "442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/RELU"; +"446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/RELU" -> "447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"448 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" -> "450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm"; +"450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" -> "451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/RELU"; +"451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/RELU" -> "452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize"; +"452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" -> "458 Inception3/InceptionE[Mixed_7b]/cat"; +"453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" -> "455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm"; +"455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" -> "456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/RELU"; +"456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/RELU" -> "457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize"; +"457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" -> "458 Inception3/InceptionE[Mixed_7b]/cat"; +"458 Inception3/InceptionE[Mixed_7b]/cat" -> "466 Inception3/InceptionE[Mixed_7b]/cat"; +"459 Inception3/InceptionE[Mixed_7b]/avg_pool2d" -> "460 Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer/asymmetric_quantize"; +"460 Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer/asymmetric_quantize" -> "462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"461 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/RELU"; +"464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/RELU" -> "465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "466 Inception3/InceptionE[Mixed_7b]/cat"; +"466 Inception3/InceptionE[Mixed_7b]/cat" -> "468 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"466 Inception3/InceptionE[Mixed_7b]/cat" -> "473 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"466 Inception3/InceptionE[Mixed_7b]/cat" -> "489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"466 Inception3/InceptionE[Mixed_7b]/cat" -> "509 Inception3/InceptionE[Mixed_7c]/avg_pool2d"; +"467 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "468 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"468 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "470 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/RELU"; +"470 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/RELU" -> "471 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"471 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "516 Inception3/InceptionE[Mixed_7c]/cat"; +"472 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "473 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"473 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" -> "474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm"; +"474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" -> "475 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/RELU"; +"475 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/RELU" -> "476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"477 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" -> "479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm"; +"479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" -> "480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/RELU"; +"480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/RELU" -> "481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize"; +"481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" -> "487 Inception3/InceptionE[Mixed_7c]/cat"; +"482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" -> "484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm"; +"484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" -> "485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/RELU"; +"485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/RELU" -> "486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize"; +"486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" -> "487 Inception3/InceptionE[Mixed_7c]/cat"; +"487 Inception3/InceptionE[Mixed_7c]/cat" -> "516 Inception3/InceptionE[Mixed_7c]/cat"; +"488 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/RELU"; +"491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/RELU" -> "492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/RELU"; +"496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/RELU" -> "497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"498 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" -> "500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm"; +"500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" -> "501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/RELU"; +"501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/RELU" -> "502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize"; +"502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" -> "508 Inception3/InceptionE[Mixed_7c]/cat"; +"503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" -> "505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm"; +"505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" -> "506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/RELU"; +"506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/RELU" -> "507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize"; +"507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" -> "508 Inception3/InceptionE[Mixed_7c]/cat"; +"508 Inception3/InceptionE[Mixed_7c]/cat" -> "516 Inception3/InceptionE[Mixed_7c]/cat"; +"509 Inception3/InceptionE[Mixed_7c]/avg_pool2d" -> "510 Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer/asymmetric_quantize"; +"510 Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer/asymmetric_quantize" -> "512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"511 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/RELU"; +"514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/RELU" -> "515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "516 Inception3/InceptionE[Mixed_7c]/cat"; +"516 Inception3/InceptionE[Mixed_7c]/cat" -> "517 Inception3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"517 Inception3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "518 Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"518 Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "519 Inception3/Dropout[dropout]/dropout"; +"519 Inception3/Dropout[dropout]/dropout" -> "521 Inception3/NNCFLinear[fc]/linear"; +"520 Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "521 Inception3/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/inception_v3_device_VPU__ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/inception_v3_device_VPU__ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..17c42ed53a0 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/inception_v3_device_VPU__ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,1082 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=3, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"4 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm" [id=4, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"5 Inception3/BasicConv2d[Conv2d_1a_3x3]/RELU" [id=5, label=RELU, scope="Inception3/BasicConv2d[Conv2d_1a_3x3]", style=filled, type=RELU]; +"6 Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#2", scope="Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=7, label="8_bit__WFQ_#2", scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"8 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=8, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"9 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm" [id=9, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"10 Inception3/BasicConv2d[Conv2d_2a_3x3]/RELU" [id=10, label=RELU, scope="Inception3/BasicConv2d[Conv2d_2a_3x3]", style=filled, type=RELU]; +"11 Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=11, label="4_bit__AFQ_#3", scope="Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"12 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=12, label="4_bit__WFQ_#3", scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"13 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=13, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"14 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm" [id=14, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"15 Inception3/BasicConv2d[Conv2d_2b_3x3]/RELU" [id=15, label=RELU, scope="Inception3/BasicConv2d[Conv2d_2b_3x3]", style=filled, type=RELU]; +"16 Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=16, label="8_bit__AFQ_#4", scope="Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"17 Inception3/MaxPool2d[maxpool1]/max_pool2d" [id=17, label=max_pool2d, scope="Inception3/MaxPool2d[maxpool1]", style=filled, type=max_pool2d]; +"18 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=18, label="8_bit__WFQ_#4", scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"19 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=19, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"20 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm" [id=20, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"21 Inception3/BasicConv2d[Conv2d_3b_1x1]/RELU" [id=21, label=RELU, scope="Inception3/BasicConv2d[Conv2d_3b_1x1]", style=filled, type=RELU]; +"22 Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=22, label="8_bit__AFQ_#5", scope="Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"23 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=23, label="4_bit__WFQ_#5", scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"24 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=24, label=conv2d, scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"25 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm" [id=25, label=batch_norm, scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"26 Inception3/BasicConv2d[Conv2d_4a_3x3]/RELU" [id=26, label=RELU, scope="Inception3/BasicConv2d[Conv2d_4a_3x3]", style=filled, type=RELU]; +"27 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=27, label="8_bit__AFQ_#6", scope="Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"28 Inception3/MaxPool2d[maxpool2]/max_pool2d" [id=28, label=max_pool2d, scope="Inception3/MaxPool2d[maxpool2]", style=filled, type=max_pool2d]; +"29 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=29, label="4_bit__WFQ_#6", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=30, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"31 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=31, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"32 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/RELU" [id=32, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"33 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=33, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"34 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=34, label="4_bit__WFQ_#6", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=35, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"36 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" [id=36, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"37 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/RELU" [id=37, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]", style=filled, type=RELU]; +"38 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=38, label="4_bit__AFQ_#10", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"39 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=39, label="8_bit__WFQ_#10", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=40, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"41 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" [id=41, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"42 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/RELU" [id=42, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]", style=filled, type=RELU]; +"43 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=43, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"44 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=44, label="4_bit__WFQ_#6", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=45, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"46 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=46, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"47 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/RELU" [id=47, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=48, label="4_bit__AFQ_#8", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=49, label="4_bit__WFQ_#8", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=50, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=51, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/RELU" [id=52, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=53, label="8_bit__AFQ_#9", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=54, label="8_bit__WFQ_#9", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=55, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=56, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/RELU" [id=57, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"58 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=58, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"59 Inception3/InceptionA[Mixed_5b]/avg_pool2d" [id=59, label=avg_pool2d, scope="Inception3/InceptionA[Mixed_5b]", style=filled, type=avg_pool2d]; +"60 Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=60, label="4_bit__AFQ_#11", scope="Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=61, label="8_bit__WFQ_#11", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=62, label=conv2d, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=63, label=batch_norm, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/RELU" [id=64, label=RELU, scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=65, label="8_bit__AFQ_#7", scope="Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"66 Inception3/InceptionA[Mixed_5b]/cat" [id=66, label=cat, scope="Inception3/InceptionA[Mixed_5b]", style=filled, type=cat]; +"67 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=67, label="4_bit__WFQ_#7", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=68, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"69 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=69, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"70 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/RELU" [id=70, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"71 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=71, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"72 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=72, label="4_bit__WFQ_#7", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=73, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"74 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" [id=74, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"75 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/RELU" [id=75, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]", style=filled, type=RELU]; +"76 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=76, label="4_bit__AFQ_#15", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"77 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=77, label="8_bit__WFQ_#15", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=78, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"79 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" [id=79, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"80 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/RELU" [id=80, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]", style=filled, type=RELU]; +"81 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=81, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"82 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=82, label="8_bit__WFQ_#7", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=83, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"84 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=84, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"85 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/RELU" [id=85, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=86, label="4_bit__AFQ_#13", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=87, label="4_bit__WFQ_#13", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=88, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=89, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/RELU" [id=90, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=91, label="8_bit__AFQ_#14", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=92, label="4_bit__WFQ_#14", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=93, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=94, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/RELU" [id=95, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"96 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=96, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"97 Inception3/InceptionA[Mixed_5c]/avg_pool2d" [id=97, label=avg_pool2d, scope="Inception3/InceptionA[Mixed_5c]", style=filled, type=avg_pool2d]; +"98 Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=98, label="8_bit__AFQ_#16", scope="Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=99, label="8_bit__WFQ_#16", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=100, label=conv2d, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=101, label=batch_norm, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/RELU" [id=102, label=RELU, scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"103 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=103, label="8_bit__AFQ_#12", scope="Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"104 Inception3/InceptionA[Mixed_5c]/cat" [id=104, label=cat, scope="Inception3/InceptionA[Mixed_5c]", style=filled, type=cat]; +"105 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=105, label="4_bit__WFQ_#12", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=106, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"107 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=107, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"108 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/RELU" [id=108, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"109 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=109, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"110 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=110, label="8_bit__WFQ_#12", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=111, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"112 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" [id=112, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"113 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/RELU" [id=113, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]", style=filled, type=RELU]; +"114 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=114, label="4_bit__AFQ_#20", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"115 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=115, label="4_bit__WFQ_#20", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=116, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"117 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" [id=117, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"118 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/RELU" [id=118, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]", style=filled, type=RELU]; +"119 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=119, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"120 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=120, label="8_bit__WFQ_#12", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=121, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"122 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=122, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"123 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/RELU" [id=123, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=124, label="4_bit__AFQ_#18", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=125, label="8_bit__WFQ_#18", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=126, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=127, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/RELU" [id=128, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=129, label="4_bit__AFQ_#19", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=130, label="8_bit__WFQ_#19", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=131, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=132, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/RELU" [id=133, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"134 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=134, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"135 Inception3/InceptionA[Mixed_5d]/avg_pool2d" [id=135, label=avg_pool2d, scope="Inception3/InceptionA[Mixed_5d]", style=filled, type=avg_pool2d]; +"136 Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=136, label="4_bit__AFQ_#21", scope="Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=137, label="4_bit__WFQ_#21", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=138, label=conv2d, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=139, label=batch_norm, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/RELU" [id=140, label=RELU, scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"141 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=141, label="8_bit__AFQ_#17", scope="Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"142 Inception3/InceptionA[Mixed_5d]/cat" [id=142, label=cat, scope="Inception3/InceptionA[Mixed_5d]", style=filled, type=cat]; +"143 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=143, label="8_bit__WFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=144, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"145 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm" [id=145, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"146 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/RELU" [id=146, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]", style=filled, type=RELU]; +"147 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=147, label="8_bit__AFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"148 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=148, label="4_bit__WFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=149, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"150 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=150, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"151 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/RELU" [id=151, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"152 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=152, label="8_bit__AFQ_#22", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"153 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=153, label="4_bit__WFQ_#22", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=154, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"155 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=155, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"156 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/RELU" [id=156, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"157 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=157, label="4_bit__AFQ_#23", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"158 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=158, label="4_bit__WFQ_#23", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=159, label=conv2d, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"160 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" [id=160, label=batch_norm, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"161 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/RELU" [id=161, label=RELU, scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]", style=filled, type=RELU]; +"162 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=162, label="8_bit__AFQ_#17", scope="Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"163 Inception3/InceptionB[Mixed_6a]/max_pool2d" [id=163, label=max_pool2d, scope="Inception3/InceptionB[Mixed_6a]", style=filled, type=max_pool2d]; +"164 Inception3/InceptionB[Mixed_6a]/cat" [id=164, label=cat, scope="Inception3/InceptionB[Mixed_6a]", style=filled, type=cat]; +"165 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=165, label="4_bit__WFQ_#17", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=166, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"167 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=167, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"168 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/RELU" [id=168, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"169 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=169, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"170 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=170, label="8_bit__WFQ_#17", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=171, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"172 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=172, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"173 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/RELU" [id=173, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"174 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=174, label="8_bit__AFQ_#25", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"175 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=175, label="8_bit__WFQ_#25", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=176, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"177 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=177, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"178 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/RELU" [id=178, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"179 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=179, label="4_bit__AFQ_#26", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"180 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=180, label="8_bit__WFQ_#26", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=181, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"182 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=182, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"183 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/RELU" [id=183, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=184, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=185, label="8_bit__WFQ_#17", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=186, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=187, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/RELU" [id=188, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=189, label="4_bit__AFQ_#27", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=190, label="4_bit__WFQ_#27", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=191, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=192, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/RELU" [id=193, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=194, label="8_bit__AFQ_#28", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=195, label="4_bit__WFQ_#28", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=196, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=197, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/RELU" [id=198, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#29", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=200, label="8_bit__WFQ_#29", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=201, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=202, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/RELU" [id=203, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=204, label="4_bit__AFQ_#30", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=205, label="8_bit__WFQ_#30", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=206, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=207, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/RELU" [id=208, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"209 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=209, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"210 Inception3/InceptionC[Mixed_6b]/avg_pool2d" [id=210, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6b]", style=filled, type=avg_pool2d]; +"211 Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=211, label="8_bit__AFQ_#31", scope="Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=212, label="4_bit__WFQ_#31", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=213, label=conv2d, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=214, label=batch_norm, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/RELU" [id=215, label=RELU, scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"216 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=216, label="8_bit__AFQ_#24", scope="Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"217 Inception3/InceptionC[Mixed_6b]/cat" [id=217, label=cat, scope="Inception3/InceptionC[Mixed_6b]", style=filled, type=cat]; +"218 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=218, label="8_bit__WFQ_#24", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=219, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"220 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=220, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"221 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/RELU" [id=221, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"222 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=222, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"223 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=223, label="8_bit__WFQ_#24", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=224, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"225 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=225, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"226 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/RELU" [id=226, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"227 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=227, label="8_bit__AFQ_#33", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"228 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=228, label="8_bit__WFQ_#33", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=229, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"230 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=230, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"231 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/RELU" [id=231, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"232 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=232, label="8_bit__AFQ_#34", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"233 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=233, label="8_bit__WFQ_#34", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=234, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"235 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=235, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"236 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/RELU" [id=236, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=237, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=238, label="8_bit__WFQ_#24", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=239, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=240, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/RELU" [id=241, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=242, label="8_bit__AFQ_#35", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=243, label="8_bit__WFQ_#35", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=244, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=245, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/RELU" [id=246, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=247, label="4_bit__AFQ_#36", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=248, label="4_bit__WFQ_#36", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=249, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=250, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/RELU" [id=251, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=252, label="4_bit__AFQ_#37", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=253, label="8_bit__WFQ_#37", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=254, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=255, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/RELU" [id=256, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=257, label="4_bit__AFQ_#38", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=258, label="8_bit__WFQ_#38", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=259, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=260, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/RELU" [id=261, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"262 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=262, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"263 Inception3/InceptionC[Mixed_6c]/avg_pool2d" [id=263, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6c]", style=filled, type=avg_pool2d]; +"264 Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=264, label="4_bit__AFQ_#39", scope="Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=265, label="8_bit__WFQ_#39", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=266, label=conv2d, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=267, label=batch_norm, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/RELU" [id=268, label=RELU, scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"269 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=269, label="8_bit__AFQ_#32", scope="Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"270 Inception3/InceptionC[Mixed_6c]/cat" [id=270, label=cat, scope="Inception3/InceptionC[Mixed_6c]", style=filled, type=cat]; +"271 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=271, label="8_bit__WFQ_#32", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=272, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"273 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=273, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"274 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/RELU" [id=274, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"275 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=275, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"276 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=276, label="8_bit__WFQ_#32", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=277, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"278 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=278, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"279 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/RELU" [id=279, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"280 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=280, label="4_bit__AFQ_#41", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"281 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=281, label="8_bit__WFQ_#41", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=282, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"283 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=283, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"284 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/RELU" [id=284, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"285 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=285, label="4_bit__AFQ_#42", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"286 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=286, label="8_bit__WFQ_#42", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=287, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"288 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=288, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"289 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/RELU" [id=289, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=290, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=291, label="4_bit__WFQ_#32", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=292, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=293, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/RELU" [id=294, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=295, label="4_bit__AFQ_#43", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=296, label="4_bit__WFQ_#43", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=297, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=298, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/RELU" [id=299, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=300, label="4_bit__AFQ_#44", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=301, label="8_bit__WFQ_#44", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=302, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=303, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/RELU" [id=304, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=305, label="8_bit__AFQ_#45", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=306, label="4_bit__WFQ_#45", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=307, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=308, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/RELU" [id=309, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=310, label="4_bit__AFQ_#46", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=311, label="8_bit__WFQ_#46", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=312, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=313, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/RELU" [id=314, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"315 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=315, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"316 Inception3/InceptionC[Mixed_6d]/avg_pool2d" [id=316, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6d]", style=filled, type=avg_pool2d]; +"317 Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=317, label="4_bit__AFQ_#47", scope="Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=318, label="4_bit__WFQ_#47", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=319, label=conv2d, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=320, label=batch_norm, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/RELU" [id=321, label=RELU, scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"322 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=322, label="8_bit__AFQ_#40", scope="Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"323 Inception3/InceptionC[Mixed_6d]/cat" [id=323, label=cat, scope="Inception3/InceptionC[Mixed_6d]", style=filled, type=cat]; +"324 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=324, label="4_bit__WFQ_#40", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=325, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"326 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=326, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"327 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/RELU" [id=327, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"328 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=328, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"329 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=329, label="4_bit__WFQ_#40", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=330, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"331 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" [id=331, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"332 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/RELU" [id=332, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]", style=filled, type=RELU]; +"333 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=333, label="8_bit__AFQ_#49", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"334 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=334, label="8_bit__WFQ_#49", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=335, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"336 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" [id=336, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"337 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/RELU" [id=337, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]", style=filled, type=RELU]; +"338 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=338, label="8_bit__AFQ_#50", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"339 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=339, label="4_bit__WFQ_#50", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=340, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"341 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" [id=341, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"342 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/RELU" [id=342, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]", style=filled, type=RELU]; +"343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" [color=green, id=343, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=344, label="4_bit__WFQ_#40", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=345, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" [id=346, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/RELU" [id=347, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]", style=filled, type=RELU]; +"348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=348, label="4_bit__AFQ_#51", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=349, label="4_bit__WFQ_#51", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=350, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" [id=351, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/RELU" [id=352, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]", style=filled, type=RELU]; +"353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=353, label="8_bit__AFQ_#52", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=354, label="4_bit__WFQ_#52", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=355, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" [id=356, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/RELU" [id=357, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]", style=filled, type=RELU]; +"358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=358, label="4_bit__AFQ_#53", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=359, label="8_bit__WFQ_#53", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=360, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" [id=361, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/RELU" [id=362, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]", style=filled, type=RELU]; +"363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=363, label="8_bit__AFQ_#54", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=364, label="4_bit__WFQ_#54", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=365, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" [id=366, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/RELU" [id=367, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]", style=filled, type=RELU]; +"368 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" [color=green, id=368, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"369 Inception3/InceptionC[Mixed_6e]/avg_pool2d" [id=369, label=avg_pool2d, scope="Inception3/InceptionC[Mixed_6e]", style=filled, type=avg_pool2d]; +"370 Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=370, label="8_bit__AFQ_#55", scope="Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=371, label="4_bit__WFQ_#55", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=372, label=conv2d, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=373, label=batch_norm, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/RELU" [id=374, label=RELU, scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"375 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=375, label="8_bit__AFQ_#48", scope="Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"376 Inception3/InceptionC[Mixed_6e]/cat" [id=376, label=cat, scope="Inception3/InceptionC[Mixed_6e]", style=filled, type=cat]; +"377 Inception3/InceptionAux[AuxLogits]/avg_pool2d" [id=377, label=avg_pool2d, scope="Inception3/InceptionAux[AuxLogits]", style=filled, type=avg_pool2d]; +"378 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]/conv2d" [id=378, label=conv2d, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]", style=filled, type=conv2d]; +"379 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]/batch_norm" [id=379, label=batch_norm, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"380 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/RELU" [id=380, label=RELU, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]", style=filled, type=RELU]; +"381 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]/conv2d" [id=381, label=conv2d, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]", style=filled, type=conv2d]; +"382 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]/batch_norm" [id=382, label=batch_norm, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"383 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/RELU" [id=383, label=RELU, scope="Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]", style=filled, type=RELU]; +"384 Inception3/InceptionAux[AuxLogits]/adaptive_avg_pool2d" [id=384, label=adaptive_avg_pool2d, scope="Inception3/InceptionAux[AuxLogits]", style=filled, type=adaptive_avg_pool2d]; +"385 Inception3/InceptionAux[AuxLogits]/Linear[fc]/linear" [id=385, label=linear, scope="Inception3/InceptionAux[AuxLogits]/Linear[fc]", style=filled, type=linear]; +"386 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=386, label="8_bit__WFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=387, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"388 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" [id=388, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"389 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/RELU" [id=389, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]", style=filled, type=RELU]; +"390 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=390, label="4_bit__AFQ_#56", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"391 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=391, label="4_bit__WFQ_#56", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=392, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"393 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm" [id=393, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"394 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/RELU" [id=394, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]", style=filled, type=RELU]; +"395 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=395, label="8_bit__AFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=396, label="8_bit__WFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=397, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm" [id=398, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/RELU" [id=399, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]", style=filled, type=RELU]; +"400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=400, label="8_bit__AFQ_#57", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=401, label="8_bit__WFQ_#57", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=402, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm" [id=403, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/RELU" [id=404, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]", style=filled, type=RELU]; +"405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=405, label="8_bit__AFQ_#58", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=406, label="4_bit__WFQ_#58", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=407, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm" [id=408, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/RELU" [id=409, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]", style=filled, type=RELU]; +"410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=410, label="8_bit__AFQ_#59", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=411, label="4_bit__WFQ_#59", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=412, label=conv2d, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm" [id=413, label=batch_norm, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/RELU" [id=414, label=RELU, scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]", style=filled, type=RELU]; +"415 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize" [color=green, id=415, label="8_bit__AFQ_#48", scope="Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"416 Inception3/InceptionD[Mixed_7a]/max_pool2d" [id=416, label=max_pool2d, scope="Inception3/InceptionD[Mixed_7a]", style=filled, type=max_pool2d]; +"417 Inception3/InceptionD[Mixed_7a]/cat" [id=417, label=cat, scope="Inception3/InceptionD[Mixed_7a]", style=filled, type=cat]; +"418 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=418, label="4_bit__WFQ_#48", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=419, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"420 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=420, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"421 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/RELU" [id=421, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"422 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=422, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"423 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=423, label="4_bit__WFQ_#48", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=424, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"425 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" [id=425, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/RELU" [id=426, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]", style=filled, type=RELU]; +"427 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=427, label="8_bit__AFQ_#61", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=428, label="4_bit__WFQ_#61", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=429, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" [id=430, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/RELU" [id=431, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]", style=filled, type=RELU]; +"432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=432, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=433, label="2_bit__WFQ_#61", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=434, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" [id=435, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/RELU" [id=436, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]", style=filled, type=RELU]; +"437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=437, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"438 Inception3/InceptionE[Mixed_7b]/cat" [id=438, label=cat, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=cat]; +"439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=439, label="8_bit__WFQ_#48", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=440, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=441, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/RELU" [id=442, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=443, label="8_bit__AFQ_#62", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=444, label="8_bit__WFQ_#62", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=445, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=446, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/RELU" [id=447, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"448 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=448, label="8_bit__AFQ_#63", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=449, label="8_bit__WFQ_#63", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=450, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" [id=451, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/RELU" [id=452, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]", style=filled, type=RELU]; +"453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=453, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=454, label="8_bit__WFQ_#63", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=455, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" [id=456, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/RELU" [id=457, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]", style=filled, type=RELU]; +"458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=458, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"459 Inception3/InceptionE[Mixed_7b]/cat" [id=459, label=cat, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=cat]; +"460 Inception3/InceptionE[Mixed_7b]/avg_pool2d" [id=460, label=avg_pool2d, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=avg_pool2d]; +"461 Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=461, label="8_bit__AFQ_#64", scope="Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=462, label="8_bit__WFQ_#64", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=463, label=conv2d, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=464, label=batch_norm, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/RELU" [id=465, label=RELU, scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"466 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=466, label="8_bit__AFQ_#60", scope="Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"467 Inception3/InceptionE[Mixed_7b]/cat" [id=467, label=cat, scope="Inception3/InceptionE[Mixed_7b]", style=filled, type=cat]; +"468 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=468, label="4_bit__WFQ_#60", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=469, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"470 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" [id=470, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"471 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/RELU" [id=471, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]", style=filled, type=RELU]; +"472 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" [color=green, id=472, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"473 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=473, label="2_bit__WFQ_#60", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=474, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"475 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" [id=475, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/RELU" [id=476, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]", style=filled, type=RELU]; +"477 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=477, label="4_bit__AFQ_#66", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=478, label="8_bit__WFQ_#66", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=479, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" [id=480, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/RELU" [id=481, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]", style=filled, type=RELU]; +"482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=482, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=483, label="8_bit__WFQ_#66", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=484, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" [id=485, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/RELU" [id=486, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]", style=filled, type=RELU]; +"487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=487, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"488 Inception3/InceptionE[Mixed_7c]/cat" [id=488, label=cat, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=cat]; +"489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=489, label="4_bit__WFQ_#60", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=490, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" [id=491, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/RELU" [id=492, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]", style=filled, type=RELU]; +"493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=493, label="4_bit__AFQ_#67", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=494, label="8_bit__WFQ_#67", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=495, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" [id=496, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/RELU" [id=497, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]", style=filled, type=RELU]; +"498 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=498, label="4_bit__AFQ_#68", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=499, label="4_bit__WFQ_#68", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=500, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" [id=501, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/RELU" [id=502, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]", style=filled, type=RELU]; +"503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" [color=green, id=503, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=504, label="4_bit__WFQ_#68", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=505, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" [id=506, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/RELU" [id=507, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]", style=filled, type=RELU]; +"508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" [color=green, id=508, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"509 Inception3/InceptionE[Mixed_7c]/cat" [id=509, label=cat, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=cat]; +"510 Inception3/InceptionE[Mixed_7c]/avg_pool2d" [id=510, label=avg_pool2d, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=avg_pool2d]; +"511 Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=511, label="4_bit__AFQ_#69", scope="Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=512, label="4_bit__WFQ_#69", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" [color=lightblue, id=513, label=conv2d, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]", style=filled, type=conv2d]; +"514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" [id=514, label=batch_norm, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]", style=filled, type=batch_norm]; +"515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/RELU" [id=515, label=RELU, scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]", style=filled, type=RELU]; +"516 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" [color=green, id=516, label="8_bit__AFQ_#65", scope="Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"517 Inception3/InceptionE[Mixed_7c]/cat" [id=517, label=cat, scope="Inception3/InceptionE[Mixed_7c]", style=filled, type=cat]; +"518 Inception3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=518, label=adaptive_avg_pool2d, scope="Inception3/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"519 Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=519, label="4_bit__AFQ_#1", scope="Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"520 Inception3/Dropout[dropout]/dropout" [id=520, label=dropout, scope="Inception3/Dropout[dropout]", style=filled, type=dropout]; +"521 Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=521, label="4_bit__WFQ_#1", scope="Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"522 Inception3/NNCFLinear[fc]/linear" [id=522, label=linear, scope="Inception3/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d"; +"2 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d"; +"3 Inception3/BasicConv2d[Conv2d_1a_3x3]/NNCFConv2d[conv]/conv2d" -> "4 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm"; +"4 Inception3/BasicConv2d[Conv2d_1a_3x3]/BatchNorm2d[bn]/batch_norm" -> "5 Inception3/BasicConv2d[Conv2d_1a_3x3]/RELU"; +"5 Inception3/BasicConv2d[Conv2d_1a_3x3]/RELU" -> "6 Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer/asymmetric_quantize"; +"6 Inception3/BasicConv2d[Conv2d_1a_3x3]/AsymmetricQuantizer/asymmetric_quantize" -> "8 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d"; +"7 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "8 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d"; +"8 Inception3/BasicConv2d[Conv2d_2a_3x3]/NNCFConv2d[conv]/conv2d" -> "9 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm"; +"9 Inception3/BasicConv2d[Conv2d_2a_3x3]/BatchNorm2d[bn]/batch_norm" -> "10 Inception3/BasicConv2d[Conv2d_2a_3x3]/RELU"; +"10 Inception3/BasicConv2d[Conv2d_2a_3x3]/RELU" -> "11 Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer/asymmetric_quantize"; +"11 Inception3/BasicConv2d[Conv2d_2a_3x3]/AsymmetricQuantizer/asymmetric_quantize" -> "13 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d"; +"12 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "13 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d"; +"13 Inception3/BasicConv2d[Conv2d_2b_3x3]/NNCFConv2d[conv]/conv2d" -> "14 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm"; +"14 Inception3/BasicConv2d[Conv2d_2b_3x3]/BatchNorm2d[bn]/batch_norm" -> "15 Inception3/BasicConv2d[Conv2d_2b_3x3]/RELU"; +"15 Inception3/BasicConv2d[Conv2d_2b_3x3]/RELU" -> "16 Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer/asymmetric_quantize"; +"16 Inception3/BasicConv2d[Conv2d_2b_3x3]/AsymmetricQuantizer/asymmetric_quantize" -> "17 Inception3/MaxPool2d[maxpool1]/max_pool2d"; +"17 Inception3/MaxPool2d[maxpool1]/max_pool2d" -> "19 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d"; +"18 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "19 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d"; +"19 Inception3/BasicConv2d[Conv2d_3b_1x1]/NNCFConv2d[conv]/conv2d" -> "20 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm"; +"20 Inception3/BasicConv2d[Conv2d_3b_1x1]/BatchNorm2d[bn]/batch_norm" -> "21 Inception3/BasicConv2d[Conv2d_3b_1x1]/RELU"; +"21 Inception3/BasicConv2d[Conv2d_3b_1x1]/RELU" -> "22 Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer/asymmetric_quantize"; +"22 Inception3/BasicConv2d[Conv2d_3b_1x1]/AsymmetricQuantizer/asymmetric_quantize" -> "24 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d"; +"23 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "24 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d"; +"24 Inception3/BasicConv2d[Conv2d_4a_3x3]/NNCFConv2d[conv]/conv2d" -> "25 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm"; +"25 Inception3/BasicConv2d[Conv2d_4a_3x3]/BatchNorm2d[bn]/batch_norm" -> "26 Inception3/BasicConv2d[Conv2d_4a_3x3]/RELU"; +"26 Inception3/BasicConv2d[Conv2d_4a_3x3]/RELU" -> "27 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize"; +"27 Inception3/BasicConv2d[Conv2d_4a_3x3]/SymmetricQuantizer/symmetric_quantize" -> "28 Inception3/MaxPool2d[maxpool2]/max_pool2d"; +"28 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"28 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"28 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"28 Inception3/MaxPool2d[maxpool2]/max_pool2d" -> "59 Inception3/InceptionA[Mixed_5b]/avg_pool2d"; +"29 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"30 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "31 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"31 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "32 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/RELU"; +"32 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/RELU" -> "33 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"33 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "66 Inception3/InceptionA[Mixed_5b]/cat"; +"34 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"35 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" -> "36 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm"; +"36 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" -> "37 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/RELU"; +"37 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/RELU" -> "38 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize"; +"38 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" -> "40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"39 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"40 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" -> "41 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm"; +"41 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" -> "42 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/RELU"; +"42 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/RELU" -> "43 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize"; +"43 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" -> "66 Inception3/InceptionA[Mixed_5b]/cat"; +"44 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"45 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "46 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"46 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "47 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/RELU"; +"47 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/RELU" -> "48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"48 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"49 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"50 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"51 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/RELU"; +"52 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/RELU" -> "53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"53 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"54 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"55 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"56 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/RELU"; +"57 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/RELU" -> "58 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"58 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "66 Inception3/InceptionA[Mixed_5b]/cat"; +"59 Inception3/InceptionA[Mixed_5b]/avg_pool2d" -> "60 Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer/asymmetric_quantize"; +"60 Inception3/InceptionA[Mixed_5b]/AsymmetricQuantizer/asymmetric_quantize" -> "62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"61 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"62 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"63 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/RELU"; +"64 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/RELU" -> "65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"65 Inception3/InceptionA[Mixed_5b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "66 Inception3/InceptionA[Mixed_5b]/cat"; +"66 Inception3/InceptionA[Mixed_5b]/cat" -> "68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"66 Inception3/InceptionA[Mixed_5b]/cat" -> "73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"66 Inception3/InceptionA[Mixed_5b]/cat" -> "83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"66 Inception3/InceptionA[Mixed_5b]/cat" -> "97 Inception3/InceptionA[Mixed_5c]/avg_pool2d"; +"67 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"68 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "69 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"69 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "70 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/RELU"; +"70 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/RELU" -> "71 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"71 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "104 Inception3/InceptionA[Mixed_5c]/cat"; +"72 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"73 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" -> "74 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm"; +"74 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" -> "75 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/RELU"; +"75 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/RELU" -> "76 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize"; +"76 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" -> "78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"77 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"78 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" -> "79 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm"; +"79 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" -> "80 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/RELU"; +"80 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/RELU" -> "81 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize"; +"81 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" -> "104 Inception3/InceptionA[Mixed_5c]/cat"; +"82 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"83 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "84 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"84 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "85 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/RELU"; +"85 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/RELU" -> "86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"86 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"87 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"88 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"89 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/RELU"; +"90 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/RELU" -> "91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"91 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"92 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"93 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"94 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/RELU"; +"95 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/RELU" -> "96 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"96 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "104 Inception3/InceptionA[Mixed_5c]/cat"; +"97 Inception3/InceptionA[Mixed_5c]/avg_pool2d" -> "98 Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer/asymmetric_quantize"; +"98 Inception3/InceptionA[Mixed_5c]/AsymmetricQuantizer/asymmetric_quantize" -> "100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"99 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"100 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"101 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/RELU"; +"102 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/RELU" -> "103 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"103 Inception3/InceptionA[Mixed_5c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "104 Inception3/InceptionA[Mixed_5c]/cat"; +"104 Inception3/InceptionA[Mixed_5c]/cat" -> "106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"104 Inception3/InceptionA[Mixed_5c]/cat" -> "111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"104 Inception3/InceptionA[Mixed_5c]/cat" -> "121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"104 Inception3/InceptionA[Mixed_5c]/cat" -> "135 Inception3/InceptionA[Mixed_5d]/avg_pool2d"; +"105 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"106 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "107 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"107 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "108 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/RELU"; +"108 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/RELU" -> "109 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"109 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "142 Inception3/InceptionA[Mixed_5d]/cat"; +"110 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d"; +"111 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/NNCFConv2d[conv]/conv2d" -> "112 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm"; +"112 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/BatchNorm2d[bn]/batch_norm" -> "113 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/RELU"; +"113 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/RELU" -> "114 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize"; +"114 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_1]/AsymmetricQuantizer/asymmetric_quantize" -> "116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"115 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d"; +"116 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/NNCFConv2d[conv]/conv2d" -> "117 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm"; +"117 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/BatchNorm2d[bn]/batch_norm" -> "118 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/RELU"; +"118 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/RELU" -> "119 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize"; +"119 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch5x5_2]/SymmetricQuantizer/symmetric_quantize" -> "142 Inception3/InceptionA[Mixed_5d]/cat"; +"120 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"121 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "122 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"122 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "123 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/RELU"; +"123 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/RELU" -> "124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"124 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"125 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"126 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"127 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/RELU"; +"128 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/RELU" -> "129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"129 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"130 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"131 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"132 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/RELU"; +"133 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/RELU" -> "134 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"134 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "142 Inception3/InceptionA[Mixed_5d]/cat"; +"135 Inception3/InceptionA[Mixed_5d]/avg_pool2d" -> "136 Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer/asymmetric_quantize"; +"136 Inception3/InceptionA[Mixed_5d]/AsymmetricQuantizer/asymmetric_quantize" -> "138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"137 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"138 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"139 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/RELU"; +"140 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/RELU" -> "141 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"141 Inception3/InceptionA[Mixed_5d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "142 Inception3/InceptionA[Mixed_5d]/cat"; +"142 Inception3/InceptionA[Mixed_5d]/cat" -> "144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d"; +"142 Inception3/InceptionA[Mixed_5d]/cat" -> "149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"142 Inception3/InceptionA[Mixed_5d]/cat" -> "163 Inception3/InceptionB[Mixed_6a]/max_pool2d"; +"143 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d"; +"144 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/NNCFConv2d[conv]/conv2d" -> "145 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm"; +"145 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/BatchNorm2d[bn]/batch_norm" -> "146 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/RELU"; +"146 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/RELU" -> "147 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize"; +"147 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3]/SymmetricQuantizer/symmetric_quantize" -> "164 Inception3/InceptionB[Mixed_6a]/cat"; +"148 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"149 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "150 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"150 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "151 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/RELU"; +"151 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/RELU" -> "152 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"152 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"153 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"154 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "155 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"155 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "156 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/RELU"; +"156 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/RELU" -> "157 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"157 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"158 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d"; +"159 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/NNCFConv2d[conv]/conv2d" -> "160 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm"; +"160 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/BatchNorm2d[bn]/batch_norm" -> "161 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/RELU"; +"161 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/RELU" -> "162 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize"; +"162 Inception3/InceptionB[Mixed_6a]/BasicConv2d[branch3x3dbl_3]/SymmetricQuantizer/symmetric_quantize" -> "164 Inception3/InceptionB[Mixed_6a]/cat"; +"163 Inception3/InceptionB[Mixed_6a]/max_pool2d" -> "164 Inception3/InceptionB[Mixed_6a]/cat"; +"164 Inception3/InceptionB[Mixed_6a]/cat" -> "166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"164 Inception3/InceptionB[Mixed_6a]/cat" -> "171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"164 Inception3/InceptionB[Mixed_6a]/cat" -> "186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"164 Inception3/InceptionB[Mixed_6a]/cat" -> "210 Inception3/InceptionC[Mixed_6b]/avg_pool2d"; +"165 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"166 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "167 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"167 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "168 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/RELU"; +"168 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/RELU" -> "169 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"169 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "217 Inception3/InceptionC[Mixed_6b]/cat"; +"170 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"171 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "172 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"172 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "173 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/RELU"; +"173 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/RELU" -> "174 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"174 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"175 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"176 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "177 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"177 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "178 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/RELU"; +"178 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/RELU" -> "179 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"179 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"180 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"181 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "182 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"182 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "183 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/RELU"; +"183 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/RELU" -> "184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"184 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "217 Inception3/InceptionC[Mixed_6b]/cat"; +"185 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"186 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"187 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/RELU"; +"188 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/RELU" -> "189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"189 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"190 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"191 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"192 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/RELU"; +"193 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/RELU" -> "194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"194 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"195 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"196 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"197 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/RELU"; +"198 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/RELU" -> "199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"199 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"200 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"201 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"202 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/RELU"; +"203 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/RELU" -> "204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"204 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"205 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"206 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"207 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/RELU"; +"208 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/RELU" -> "209 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"209 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "217 Inception3/InceptionC[Mixed_6b]/cat"; +"210 Inception3/InceptionC[Mixed_6b]/avg_pool2d" -> "211 Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer/asymmetric_quantize"; +"211 Inception3/InceptionC[Mixed_6b]/AsymmetricQuantizer/asymmetric_quantize" -> "213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"212 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"213 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"214 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/RELU"; +"215 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/RELU" -> "216 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"216 Inception3/InceptionC[Mixed_6b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "217 Inception3/InceptionC[Mixed_6b]/cat"; +"217 Inception3/InceptionC[Mixed_6b]/cat" -> "219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"217 Inception3/InceptionC[Mixed_6b]/cat" -> "224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"217 Inception3/InceptionC[Mixed_6b]/cat" -> "239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"217 Inception3/InceptionC[Mixed_6b]/cat" -> "263 Inception3/InceptionC[Mixed_6c]/avg_pool2d"; +"218 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"219 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "220 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"220 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "221 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/RELU"; +"221 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/RELU" -> "222 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"222 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "270 Inception3/InceptionC[Mixed_6c]/cat"; +"223 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"224 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "225 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"225 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "226 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/RELU"; +"226 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/RELU" -> "227 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"227 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"228 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"229 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "230 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"230 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "231 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/RELU"; +"231 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/RELU" -> "232 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"232 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"233 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"234 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "235 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"235 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "236 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/RELU"; +"236 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/RELU" -> "237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"237 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "270 Inception3/InceptionC[Mixed_6c]/cat"; +"238 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"239 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"240 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/RELU"; +"241 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/RELU" -> "242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"242 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"243 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"244 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"245 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/RELU"; +"246 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/RELU" -> "247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"247 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"248 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"249 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"250 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/RELU"; +"251 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/RELU" -> "252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"252 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"253 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"254 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"255 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/RELU"; +"256 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/RELU" -> "257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"257 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"258 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"259 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"260 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/RELU"; +"261 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/RELU" -> "262 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"262 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "270 Inception3/InceptionC[Mixed_6c]/cat"; +"263 Inception3/InceptionC[Mixed_6c]/avg_pool2d" -> "264 Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer/asymmetric_quantize"; +"264 Inception3/InceptionC[Mixed_6c]/AsymmetricQuantizer/asymmetric_quantize" -> "266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"265 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"266 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"267 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/RELU"; +"268 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/RELU" -> "269 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"269 Inception3/InceptionC[Mixed_6c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "270 Inception3/InceptionC[Mixed_6c]/cat"; +"270 Inception3/InceptionC[Mixed_6c]/cat" -> "272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"270 Inception3/InceptionC[Mixed_6c]/cat" -> "277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"270 Inception3/InceptionC[Mixed_6c]/cat" -> "292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"270 Inception3/InceptionC[Mixed_6c]/cat" -> "316 Inception3/InceptionC[Mixed_6d]/avg_pool2d"; +"271 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"272 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "273 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"273 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "274 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/RELU"; +"274 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/RELU" -> "275 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"275 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "323 Inception3/InceptionC[Mixed_6d]/cat"; +"276 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"277 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "278 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"278 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "279 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/RELU"; +"279 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/RELU" -> "280 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"280 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"281 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"282 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "283 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"283 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "284 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/RELU"; +"284 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/RELU" -> "285 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"285 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"286 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"287 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "288 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"288 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "289 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/RELU"; +"289 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/RELU" -> "290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"290 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "323 Inception3/InceptionC[Mixed_6d]/cat"; +"291 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"292 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"293 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/RELU"; +"294 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/RELU" -> "295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"295 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"296 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"297 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"298 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/RELU"; +"299 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/RELU" -> "300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"300 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"301 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"302 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"303 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/RELU"; +"304 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/RELU" -> "305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"305 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"306 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"307 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"308 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/RELU"; +"309 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/RELU" -> "310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"310 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"311 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"312 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"313 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/RELU"; +"314 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/RELU" -> "315 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"315 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "323 Inception3/InceptionC[Mixed_6d]/cat"; +"316 Inception3/InceptionC[Mixed_6d]/avg_pool2d" -> "317 Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer/asymmetric_quantize"; +"317 Inception3/InceptionC[Mixed_6d]/AsymmetricQuantizer/asymmetric_quantize" -> "319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"318 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"319 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"320 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/RELU"; +"321 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/RELU" -> "322 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"322 Inception3/InceptionC[Mixed_6d]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "323 Inception3/InceptionC[Mixed_6d]/cat"; +"323 Inception3/InceptionC[Mixed_6d]/cat" -> "325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"323 Inception3/InceptionC[Mixed_6d]/cat" -> "330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"323 Inception3/InceptionC[Mixed_6d]/cat" -> "345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"323 Inception3/InceptionC[Mixed_6d]/cat" -> "369 Inception3/InceptionC[Mixed_6e]/avg_pool2d"; +"324 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"325 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "326 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"326 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "327 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/RELU"; +"327 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/RELU" -> "328 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"328 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "376 Inception3/InceptionC[Mixed_6e]/cat"; +"329 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d"; +"330 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/NNCFConv2d[conv]/conv2d" -> "331 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm"; +"331 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/BatchNorm2d[bn]/batch_norm" -> "332 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/RELU"; +"332 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/RELU" -> "333 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize"; +"333 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_1]/AsymmetricQuantizer/asymmetric_quantize" -> "335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"334 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d"; +"335 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/NNCFConv2d[conv]/conv2d" -> "336 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm"; +"336 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/BatchNorm2d[bn]/batch_norm" -> "337 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/RELU"; +"337 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/RELU" -> "338 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize"; +"338 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_2]/AsymmetricQuantizer/asymmetric_quantize" -> "340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"339 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d"; +"340 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/NNCFConv2d[conv]/conv2d" -> "341 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm"; +"341 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/BatchNorm2d[bn]/batch_norm" -> "342 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/RELU"; +"342 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/RELU" -> "343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize"; +"343 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7_3]/SymmetricQuantizer/symmetric_quantize" -> "376 Inception3/InceptionC[Mixed_6e]/cat"; +"344 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d"; +"345 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/NNCFConv2d[conv]/conv2d" -> "346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm"; +"346 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/BatchNorm2d[bn]/batch_norm" -> "347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/RELU"; +"347 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/RELU" -> "348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"348 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"349 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d"; +"350 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/NNCFConv2d[conv]/conv2d" -> "351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm"; +"351 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/BatchNorm2d[bn]/batch_norm" -> "352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/RELU"; +"352 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/RELU" -> "353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"353 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"354 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d"; +"355 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/NNCFConv2d[conv]/conv2d" -> "356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm"; +"356 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/BatchNorm2d[bn]/batch_norm" -> "357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/RELU"; +"357 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/RELU" -> "358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize"; +"358 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_3]/AsymmetricQuantizer/asymmetric_quantize" -> "360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"359 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d"; +"360 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/NNCFConv2d[conv]/conv2d" -> "361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm"; +"361 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/BatchNorm2d[bn]/batch_norm" -> "362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/RELU"; +"362 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/RELU" -> "363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize"; +"363 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_4]/AsymmetricQuantizer/asymmetric_quantize" -> "365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"364 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d"; +"365 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/NNCFConv2d[conv]/conv2d" -> "366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm"; +"366 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/BatchNorm2d[bn]/batch_norm" -> "367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/RELU"; +"367 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/RELU" -> "368 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize"; +"368 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch7x7dbl_5]/SymmetricQuantizer/symmetric_quantize" -> "376 Inception3/InceptionC[Mixed_6e]/cat"; +"369 Inception3/InceptionC[Mixed_6e]/avg_pool2d" -> "370 Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer/asymmetric_quantize"; +"370 Inception3/InceptionC[Mixed_6e]/AsymmetricQuantizer/asymmetric_quantize" -> "372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"371 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"372 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"373 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/RELU"; +"374 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/RELU" -> "375 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"375 Inception3/InceptionC[Mixed_6e]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "376 Inception3/InceptionC[Mixed_6e]/cat"; +"376 Inception3/InceptionC[Mixed_6e]/cat" -> "377 Inception3/InceptionAux[AuxLogits]/avg_pool2d"; +"376 Inception3/InceptionC[Mixed_6e]/cat" -> "387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"376 Inception3/InceptionC[Mixed_6e]/cat" -> "397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d"; +"376 Inception3/InceptionC[Mixed_6e]/cat" -> "416 Inception3/InceptionD[Mixed_7a]/max_pool2d"; +"377 Inception3/InceptionAux[AuxLogits]/avg_pool2d" -> "378 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]/conv2d"; +"378 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/Conv2d[conv]/conv2d" -> "379 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]/batch_norm"; +"379 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/BatchNorm2d[bn]/batch_norm" -> "380 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/RELU"; +"380 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv0]/RELU" -> "381 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]/conv2d"; +"381 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/Conv2d[conv]/conv2d" -> "382 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]/batch_norm"; +"382 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/BatchNorm2d[bn]/batch_norm" -> "383 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/RELU"; +"383 Inception3/InceptionAux[AuxLogits]/BasicConv2d[conv1]/RELU" -> "384 Inception3/InceptionAux[AuxLogits]/adaptive_avg_pool2d"; +"384 Inception3/InceptionAux[AuxLogits]/adaptive_avg_pool2d" -> "385 Inception3/InceptionAux[AuxLogits]/Linear[fc]/linear"; +"386 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"387 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" -> "388 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm"; +"388 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" -> "389 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/RELU"; +"389 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/RELU" -> "390 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"390 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d"; +"391 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d"; +"392 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/NNCFConv2d[conv]/conv2d" -> "393 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm"; +"393 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/BatchNorm2d[bn]/batch_norm" -> "394 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/RELU"; +"394 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/RELU" -> "395 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize"; +"395 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch3x3_2]/SymmetricQuantizer/symmetric_quantize" -> "417 Inception3/InceptionD[Mixed_7a]/cat"; +"396 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d"; +"397 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/NNCFConv2d[conv]/conv2d" -> "398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm"; +"398 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/BatchNorm2d[bn]/batch_norm" -> "399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/RELU"; +"399 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/RELU" -> "400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"400 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d"; +"401 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d"; +"402 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/NNCFConv2d[conv]/conv2d" -> "403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm"; +"403 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/BatchNorm2d[bn]/batch_norm" -> "404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/RELU"; +"404 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/RELU" -> "405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer/asymmetric_quantize"; +"405 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_2]/AsymmetricQuantizer/asymmetric_quantize" -> "407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d"; +"406 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d"; +"407 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/NNCFConv2d[conv]/conv2d" -> "408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm"; +"408 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/BatchNorm2d[bn]/batch_norm" -> "409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/RELU"; +"409 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/RELU" -> "410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer/asymmetric_quantize"; +"410 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_3]/AsymmetricQuantizer/asymmetric_quantize" -> "412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d"; +"411 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d"; +"412 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/NNCFConv2d[conv]/conv2d" -> "413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm"; +"413 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/BatchNorm2d[bn]/batch_norm" -> "414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/RELU"; +"414 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/RELU" -> "415 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize"; +"415 Inception3/InceptionD[Mixed_7a]/BasicConv2d[branch7x7x3_4]/SymmetricQuantizer/symmetric_quantize" -> "417 Inception3/InceptionD[Mixed_7a]/cat"; +"416 Inception3/InceptionD[Mixed_7a]/max_pool2d" -> "417 Inception3/InceptionD[Mixed_7a]/cat"; +"417 Inception3/InceptionD[Mixed_7a]/cat" -> "419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"417 Inception3/InceptionD[Mixed_7a]/cat" -> "424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"417 Inception3/InceptionD[Mixed_7a]/cat" -> "440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"417 Inception3/InceptionD[Mixed_7a]/cat" -> "460 Inception3/InceptionE[Mixed_7b]/avg_pool2d"; +"418 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"419 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "420 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"420 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "421 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/RELU"; +"421 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/RELU" -> "422 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"422 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "467 Inception3/InceptionE[Mixed_7b]/cat"; +"423 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"424 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" -> "425 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm"; +"425 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" -> "426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/RELU"; +"426 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/RELU" -> "427 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"427 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"427 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"428 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"429 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" -> "430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm"; +"430 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" -> "431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/RELU"; +"431 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/RELU" -> "432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize"; +"432 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" -> "438 Inception3/InceptionE[Mixed_7b]/cat"; +"433 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"434 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" -> "435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm"; +"435 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" -> "436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/RELU"; +"436 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/RELU" -> "437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize"; +"437 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" -> "438 Inception3/InceptionE[Mixed_7b]/cat"; +"438 Inception3/InceptionE[Mixed_7b]/cat" -> "467 Inception3/InceptionE[Mixed_7b]/cat"; +"439 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"440 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"441 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/RELU"; +"442 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/RELU" -> "443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"443 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"444 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"445 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"446 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/RELU"; +"447 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/RELU" -> "448 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"448 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"448 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"449 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"450 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" -> "451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm"; +"451 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" -> "452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/RELU"; +"452 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/RELU" -> "453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize"; +"453 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" -> "459 Inception3/InceptionE[Mixed_7b]/cat"; +"454 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"455 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" -> "456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm"; +"456 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" -> "457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/RELU"; +"457 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/RELU" -> "458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize"; +"458 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" -> "459 Inception3/InceptionE[Mixed_7b]/cat"; +"459 Inception3/InceptionE[Mixed_7b]/cat" -> "467 Inception3/InceptionE[Mixed_7b]/cat"; +"460 Inception3/InceptionE[Mixed_7b]/avg_pool2d" -> "461 Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer/asymmetric_quantize"; +"461 Inception3/InceptionE[Mixed_7b]/AsymmetricQuantizer/asymmetric_quantize" -> "463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"462 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"463 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"464 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/RELU"; +"465 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/RELU" -> "466 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"466 Inception3/InceptionE[Mixed_7b]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "467 Inception3/InceptionE[Mixed_7b]/cat"; +"467 Inception3/InceptionE[Mixed_7b]/cat" -> "469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"467 Inception3/InceptionE[Mixed_7b]/cat" -> "474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"467 Inception3/InceptionE[Mixed_7b]/cat" -> "490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"467 Inception3/InceptionE[Mixed_7b]/cat" -> "510 Inception3/InceptionE[Mixed_7c]/avg_pool2d"; +"468 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d"; +"469 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/NNCFConv2d[conv]/conv2d" -> "470 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm"; +"470 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/BatchNorm2d[bn]/batch_norm" -> "471 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/RELU"; +"471 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/RELU" -> "472 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize"; +"472 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch1x1]/SymmetricQuantizer/symmetric_quantize" -> "517 Inception3/InceptionE[Mixed_7c]/cat"; +"473 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d"; +"474 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/NNCFConv2d[conv]/conv2d" -> "475 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm"; +"475 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/BatchNorm2d[bn]/batch_norm" -> "476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/RELU"; +"476 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/RELU" -> "477 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize"; +"477 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"477 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_1]/AsymmetricQuantizer/asymmetric_quantize" -> "484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"478 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d"; +"479 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/NNCFConv2d[conv]/conv2d" -> "480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm"; +"480 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/BatchNorm2d[bn]/batch_norm" -> "481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/RELU"; +"481 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/RELU" -> "482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize"; +"482 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2a]/SymmetricQuantizer/symmetric_quantize" -> "488 Inception3/InceptionE[Mixed_7c]/cat"; +"483 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d"; +"484 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/NNCFConv2d[conv]/conv2d" -> "485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm"; +"485 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/BatchNorm2d[bn]/batch_norm" -> "486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/RELU"; +"486 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/RELU" -> "487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize"; +"487 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3_2b]/SymmetricQuantizer/symmetric_quantize" -> "488 Inception3/InceptionE[Mixed_7c]/cat"; +"488 Inception3/InceptionE[Mixed_7c]/cat" -> "517 Inception3/InceptionE[Mixed_7c]/cat"; +"489 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d"; +"490 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/NNCFConv2d[conv]/conv2d" -> "491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm"; +"491 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/BatchNorm2d[bn]/batch_norm" -> "492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/RELU"; +"492 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/RELU" -> "493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize"; +"493 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_1]/AsymmetricQuantizer/asymmetric_quantize" -> "495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"494 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d"; +"495 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/NNCFConv2d[conv]/conv2d" -> "496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm"; +"496 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/BatchNorm2d[bn]/batch_norm" -> "497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/RELU"; +"497 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/RELU" -> "498 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize"; +"498 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"498 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_2]/AsymmetricQuantizer/asymmetric_quantize" -> "505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"499 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d"; +"500 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/NNCFConv2d[conv]/conv2d" -> "501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm"; +"501 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/BatchNorm2d[bn]/batch_norm" -> "502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/RELU"; +"502 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/RELU" -> "503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize"; +"503 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3a]/SymmetricQuantizer/symmetric_quantize" -> "509 Inception3/InceptionE[Mixed_7c]/cat"; +"504 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d"; +"505 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/NNCFConv2d[conv]/conv2d" -> "506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm"; +"506 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/BatchNorm2d[bn]/batch_norm" -> "507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/RELU"; +"507 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/RELU" -> "508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize"; +"508 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch3x3dbl_3b]/SymmetricQuantizer/symmetric_quantize" -> "509 Inception3/InceptionE[Mixed_7c]/cat"; +"509 Inception3/InceptionE[Mixed_7c]/cat" -> "517 Inception3/InceptionE[Mixed_7c]/cat"; +"510 Inception3/InceptionE[Mixed_7c]/avg_pool2d" -> "511 Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer/asymmetric_quantize"; +"511 Inception3/InceptionE[Mixed_7c]/AsymmetricQuantizer/asymmetric_quantize" -> "513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"512 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d"; +"513 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/NNCFConv2d[conv]/conv2d" -> "514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm"; +"514 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/BatchNorm2d[bn]/batch_norm" -> "515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/RELU"; +"515 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/RELU" -> "516 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize"; +"516 Inception3/InceptionE[Mixed_7c]/BasicConv2d[branch_pool]/SymmetricQuantizer/symmetric_quantize" -> "517 Inception3/InceptionE[Mixed_7c]/cat"; +"517 Inception3/InceptionE[Mixed_7c]/cat" -> "518 Inception3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"518 Inception3/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "519 Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"519 Inception3/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "520 Inception3/Dropout[dropout]/dropout"; +"520 Inception3/Dropout[dropout]/dropout" -> "522 Inception3/NNCFLinear[fc]/linear"; +"521 Inception3/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "522 Inception3/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__eval_subset_ratio_0.4__ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__eval_subset_ratio_0.4__ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..de106b39beb --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__eval_subset_ratio_0.4__ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,551 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=4, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=5, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#1", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=7, label="8_bit__WFQ_#1", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=purple, id=8, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=9, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=10, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=11, label="4_bit__AFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=12, label="8_bit__WFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" [color=lightblue, id=13, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]", style=filled, type=conv2d]; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" [id=14, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]", style=filled, type=batch_norm]; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=15, label="4_bit__AFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=16, label="8_bit__WFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=17, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=18, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=19, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=20, label="8_bit__AFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=21, label="8_bit__WFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=22, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=23, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=24, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=26, label="8_bit__WFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=27, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=28, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=29, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=30, label="8_bit__WFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=31, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=32, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=33, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=34, label="8_bit__AFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=35, label="8_bit__WFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=36, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=37, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=38, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=39, label="4_bit__AFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=40, label="4_bit__WFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=41, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=42, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=43, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" [id=44, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]", style=filled, type=__add__]; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=47, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=48, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=49, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=50, label="8_bit__AFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=52, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=53, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=54, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=55, label="4_bit__AFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=56, label="4_bit__WFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=57, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=58, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=59, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=60, label="8_bit__WFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=61, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=62, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=63, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=64, label="8_bit__AFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=65, label="8_bit__WFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=66, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=67, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=68, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=69, label="8_bit__AFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=70, label="4_bit__WFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=71, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=72, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=73, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" [id=74, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]", style=filled, type=__add__]; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=75, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=76, label="8_bit__WFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=77, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=78, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=79, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=80, label="8_bit__AFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=81, label="8_bit__WFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=82, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=83, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=84, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=85, label="8_bit__AFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=86, label="8_bit__WFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=87, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=88, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=89, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" [id=90, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]", style=filled, type=__add__]; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=91, label="4_bit__AFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=92, label="4_bit__WFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=93, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=94, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=95, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=96, label="8_bit__AFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=97, label="8_bit__WFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=98, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=99, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=100, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=101, label="8_bit__AFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=102, label="4_bit__WFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=103, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=104, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=106, label="4_bit__WFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=107, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=108, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=109, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=111, label="8_bit__WFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=112, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=113, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=114, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=115, label="8_bit__AFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=116, label="8_bit__WFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=117, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=118, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=119, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" [id=120, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]", style=filled, type=__add__]; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=121, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=122, label="4_bit__WFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=123, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=124, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=125, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=126, label="8_bit__AFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=127, label="8_bit__WFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=128, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=129, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=130, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=131, label="4_bit__AFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=132, label="8_bit__WFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=133, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=134, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=135, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" [id=136, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]", style=filled, type=__add__]; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=137, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=138, label="8_bit__WFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=139, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=140, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=141, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=142, label="8_bit__AFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=143, label="2_bit__WFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=144, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=145, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=146, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=147, label="4_bit__AFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=148, label="8_bit__WFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=149, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=150, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=151, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" [id=152, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]", style=filled, type=__add__]; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=153, label="8_bit__AFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=154, label="8_bit__WFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=155, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=156, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=157, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=158, label="8_bit__AFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=159, label="4_bit__WFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=160, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=161, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=162, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=163, label="4_bit__AFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=164, label="8_bit__WFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=165, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=166, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=167, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=168, label="4_bit__WFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=169, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=170, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=171, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=172, label="8_bit__AFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=173, label="2_bit__WFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=174, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=175, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=176, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=180, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=181, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" [id=182, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]", style=filled, type=__add__]; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=183, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=184, label="8_bit__WFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=185, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=186, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=187, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=188, label="8_bit__AFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=189, label="8_bit__WFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=190, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=191, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=192, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=193, label="8_bit__AFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=194, label="8_bit__WFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=195, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=196, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=197, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" [id=198, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]", style=filled, type=__add__]; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=200, label="8_bit__WFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=201, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=202, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=203, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=204, label="8_bit__AFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=205, label="4_bit__WFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=206, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=207, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=208, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=209, label="4_bit__AFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=210, label="4_bit__WFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=211, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=212, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=213, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=214, label="8_bit__WFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=215, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=216, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=217, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=218, label="8_bit__AFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=219, label="4_bit__WFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=220, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=221, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=222, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=224, label="4_bit__WFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=225, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=226, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=227, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" [id=228, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]", style=filled, type=__add__]; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=229, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=230, label="4_bit__WFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=231, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=232, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=233, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=234, label="8_bit__AFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=235, label="4_bit__WFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=236, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=237, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=238, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=239, label="4_bit__AFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=240, label="2_bit__WFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=241, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=242, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=243, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" [id=244, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]", style=filled, type=__add__]; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=245, label="4_bit__AFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=247, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=248, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=249, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=250, label="8_bit__AFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=252, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=253, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=254, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=255, label="8_bit__AFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=256, label="8_bit__WFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=257, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=258, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=259, label="4_bit__AFQ_#25", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=260, label="8_bit__WFQ_#25", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" [color=lightblue, id=261, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]", style=filled, type=conv2d]; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" [id=262, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" [id=263, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]", style=filled, type=hardtanh]; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=264, label="8_bit__AFQ_#2", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"265 MobileNetV2/adaptive_avg_pool2d" [id=265, label=adaptive_avg_pool2d, scope=MobileNetV2, style=filled, type=adaptive_avg_pool2d]; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#53", scope="MobileNetV2/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" [id=267, label=dropout, scope="MobileNetV2/Sequential[classifier]/Dropout[0]", style=filled, type=dropout]; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=268, label="2_bit__WFQ_#53", scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear" [id=269, label=linear, scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" -> "14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm"; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize"; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" -> "45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize"; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize"; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" -> "121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" -> "137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" -> "153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize"; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" -> "183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize"; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" -> "245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize"; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" -> "262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm"; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" -> "263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh"; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" -> "264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "265 MobileNetV2/adaptive_avg_pool2d"; +"265 MobileNetV2/adaptive_avg_pool2d" -> "266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize"; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" -> "267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout"; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..ceb32a1ef46 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,551 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=4, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=5, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#1", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=7, label="8_bit__WFQ_#1", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=purple, id=8, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=9, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=10, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=11, label="4_bit__AFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=12, label="8_bit__WFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" [color=lightblue, id=13, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]", style=filled, type=conv2d]; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" [id=14, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]", style=filled, type=batch_norm]; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=15, label="4_bit__AFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=16, label="8_bit__WFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=17, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=18, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=19, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=20, label="8_bit__AFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=21, label="8_bit__WFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=22, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=23, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=24, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=26, label="8_bit__WFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=27, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=28, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=29, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=30, label="8_bit__WFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=31, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=32, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=33, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=34, label="8_bit__AFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=35, label="8_bit__WFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=36, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=37, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=38, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=39, label="4_bit__AFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=40, label="4_bit__WFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=41, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=42, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=43, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" [id=44, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]", style=filled, type=__add__]; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=47, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=48, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=49, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=50, label="8_bit__AFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=52, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=53, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=54, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=55, label="4_bit__AFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=56, label="4_bit__WFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=57, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=58, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=59, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=60, label="8_bit__WFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=61, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=62, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=63, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=64, label="8_bit__AFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=65, label="8_bit__WFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=66, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=67, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=68, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=69, label="8_bit__AFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=70, label="4_bit__WFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=71, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=72, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=73, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" [id=74, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]", style=filled, type=__add__]; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=75, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=76, label="8_bit__WFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=77, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=78, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=79, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=80, label="8_bit__AFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=81, label="8_bit__WFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=82, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=83, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=84, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=85, label="8_bit__AFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=86, label="8_bit__WFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=87, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=88, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=89, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" [id=90, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]", style=filled, type=__add__]; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=91, label="4_bit__AFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=92, label="4_bit__WFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=93, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=94, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=95, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=96, label="8_bit__AFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=97, label="8_bit__WFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=98, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=99, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=100, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=101, label="8_bit__AFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=102, label="4_bit__WFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=103, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=104, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=106, label="4_bit__WFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=107, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=108, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=109, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=111, label="8_bit__WFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=112, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=113, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=114, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=115, label="8_bit__AFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=116, label="8_bit__WFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=117, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=118, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=119, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" [id=120, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]", style=filled, type=__add__]; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=121, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=122, label="4_bit__WFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=123, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=124, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=125, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=126, label="8_bit__AFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=127, label="8_bit__WFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=128, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=129, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=130, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=131, label="4_bit__AFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=132, label="8_bit__WFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=133, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=134, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=135, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" [id=136, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]", style=filled, type=__add__]; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=137, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=138, label="8_bit__WFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=139, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=140, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=141, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=142, label="8_bit__AFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=143, label="2_bit__WFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=144, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=145, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=146, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=147, label="4_bit__AFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=148, label="8_bit__WFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=149, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=150, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=151, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" [id=152, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]", style=filled, type=__add__]; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=153, label="8_bit__AFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=154, label="8_bit__WFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=155, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=156, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=157, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=158, label="8_bit__AFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=159, label="4_bit__WFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=160, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=161, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=162, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=163, label="4_bit__AFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=164, label="8_bit__WFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=165, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=166, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=167, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=168, label="4_bit__WFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=169, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=170, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=171, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=172, label="8_bit__AFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=173, label="2_bit__WFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=174, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=175, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=176, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=180, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=181, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" [id=182, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]", style=filled, type=__add__]; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=183, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=184, label="8_bit__WFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=185, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=186, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=187, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=188, label="8_bit__AFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=189, label="8_bit__WFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=190, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=191, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=192, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=193, label="8_bit__AFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=194, label="8_bit__WFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=195, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=196, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=197, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" [id=198, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]", style=filled, type=__add__]; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=200, label="8_bit__WFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=201, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=202, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=203, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=204, label="8_bit__AFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=205, label="4_bit__WFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=206, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=207, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=208, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=209, label="4_bit__AFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=210, label="4_bit__WFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=211, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=212, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=213, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=214, label="8_bit__WFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=215, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=216, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=217, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=218, label="8_bit__AFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=219, label="4_bit__WFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=220, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=221, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=222, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=224, label="4_bit__WFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=225, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=226, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=227, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" [id=228, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]", style=filled, type=__add__]; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=229, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=230, label="4_bit__WFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=231, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=232, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=233, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=234, label="8_bit__AFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=235, label="4_bit__WFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=236, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=237, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=238, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=239, label="4_bit__AFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=240, label="2_bit__WFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=241, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=242, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=243, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" [id=244, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]", style=filled, type=__add__]; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=245, label="4_bit__AFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=247, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=248, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=249, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=250, label="8_bit__AFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=252, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=253, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=254, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=255, label="8_bit__AFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=256, label="8_bit__WFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=257, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=258, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=259, label="4_bit__AFQ_#25", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=260, label="4_bit__WFQ_#25", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" [color=lightblue, id=261, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]", style=filled, type=conv2d]; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" [id=262, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" [id=263, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]", style=filled, type=hardtanh]; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=264, label="8_bit__AFQ_#2", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"265 MobileNetV2/adaptive_avg_pool2d" [id=265, label=adaptive_avg_pool2d, scope=MobileNetV2, style=filled, type=adaptive_avg_pool2d]; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#53", scope="MobileNetV2/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" [id=267, label=dropout, scope="MobileNetV2/Sequential[classifier]/Dropout[0]", style=filled, type=dropout]; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=268, label="2_bit__WFQ_#53", scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear" [id=269, label=linear, scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" -> "14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm"; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize"; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" -> "45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize"; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize"; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" -> "121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" -> "137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" -> "153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize"; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" -> "183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize"; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" -> "245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize"; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" -> "262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm"; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" -> "263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh"; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" -> "264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "265 MobileNetV2/adaptive_avg_pool2d"; +"265 MobileNetV2/adaptive_avg_pool2d" -> "266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize"; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" -> "267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout"; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..de106b39beb --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,551 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=4, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=5, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#1", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=7, label="8_bit__WFQ_#1", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=purple, id=8, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=9, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=10, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=11, label="4_bit__AFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=12, label="8_bit__WFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" [color=lightblue, id=13, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]", style=filled, type=conv2d]; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" [id=14, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]", style=filled, type=batch_norm]; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=15, label="4_bit__AFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=16, label="8_bit__WFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=17, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=18, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=19, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=20, label="8_bit__AFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=21, label="8_bit__WFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=22, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=23, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=24, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=26, label="8_bit__WFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=27, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=28, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=29, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=30, label="8_bit__WFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=31, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=32, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=33, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=34, label="8_bit__AFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=35, label="8_bit__WFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=36, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=37, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=38, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=39, label="4_bit__AFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=40, label="4_bit__WFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=41, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=42, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=43, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" [id=44, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]", style=filled, type=__add__]; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=47, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=48, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=49, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=50, label="8_bit__AFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=52, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=53, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=54, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=55, label="4_bit__AFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=56, label="4_bit__WFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=57, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=58, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=59, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=60, label="8_bit__WFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=61, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=62, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=63, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=64, label="8_bit__AFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=65, label="8_bit__WFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=66, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=67, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=68, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=69, label="8_bit__AFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=70, label="4_bit__WFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=71, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=72, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=73, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" [id=74, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]", style=filled, type=__add__]; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=75, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=76, label="8_bit__WFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=77, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=78, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=79, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=80, label="8_bit__AFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=81, label="8_bit__WFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=82, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=83, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=84, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=85, label="8_bit__AFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=86, label="8_bit__WFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=87, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=88, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=89, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" [id=90, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]", style=filled, type=__add__]; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=91, label="4_bit__AFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=92, label="4_bit__WFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=93, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=94, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=95, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=96, label="8_bit__AFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=97, label="8_bit__WFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=98, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=99, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=100, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=101, label="8_bit__AFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=102, label="4_bit__WFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=103, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=104, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=106, label="4_bit__WFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=107, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=108, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=109, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=111, label="8_bit__WFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=112, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=113, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=114, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=115, label="8_bit__AFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=116, label="8_bit__WFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=117, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=118, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=119, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" [id=120, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]", style=filled, type=__add__]; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=121, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=122, label="4_bit__WFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=123, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=124, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=125, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=126, label="8_bit__AFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=127, label="8_bit__WFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=128, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=129, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=130, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=131, label="4_bit__AFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=132, label="8_bit__WFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=133, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=134, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=135, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" [id=136, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]", style=filled, type=__add__]; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=137, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=138, label="8_bit__WFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=139, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=140, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=141, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=142, label="8_bit__AFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=143, label="2_bit__WFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=144, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=145, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=146, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=147, label="4_bit__AFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=148, label="8_bit__WFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=149, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=150, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=151, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" [id=152, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]", style=filled, type=__add__]; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=153, label="8_bit__AFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=154, label="8_bit__WFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=155, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=156, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=157, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=158, label="8_bit__AFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=159, label="4_bit__WFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=160, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=161, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=162, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=163, label="4_bit__AFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=164, label="8_bit__WFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=165, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=166, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=167, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=168, label="4_bit__WFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=169, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=170, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=171, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=172, label="8_bit__AFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=173, label="2_bit__WFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=174, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=175, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=176, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=180, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=181, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" [id=182, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]", style=filled, type=__add__]; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=183, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=184, label="8_bit__WFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=185, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=186, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=187, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=188, label="8_bit__AFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=189, label="8_bit__WFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=190, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=191, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=192, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=193, label="8_bit__AFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=194, label="8_bit__WFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=195, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=196, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=197, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" [id=198, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]", style=filled, type=__add__]; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=200, label="8_bit__WFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=201, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=202, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=203, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=204, label="8_bit__AFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=205, label="4_bit__WFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=206, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=207, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=208, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=209, label="4_bit__AFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=210, label="4_bit__WFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=211, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=212, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=213, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=214, label="8_bit__WFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=215, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=216, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=217, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=218, label="8_bit__AFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=219, label="4_bit__WFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=220, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=221, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=222, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=224, label="4_bit__WFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=225, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=226, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=227, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" [id=228, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]", style=filled, type=__add__]; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=229, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=230, label="4_bit__WFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=231, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=232, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=233, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=234, label="8_bit__AFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=235, label="4_bit__WFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=236, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=237, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=238, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=239, label="4_bit__AFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=240, label="2_bit__WFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=241, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=242, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=243, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" [id=244, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]", style=filled, type=__add__]; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=245, label="4_bit__AFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=247, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=248, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=249, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=250, label="8_bit__AFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=252, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=253, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=254, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=255, label="8_bit__AFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=256, label="8_bit__WFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=257, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=258, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=259, label="4_bit__AFQ_#25", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=260, label="8_bit__WFQ_#25", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" [color=lightblue, id=261, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]", style=filled, type=conv2d]; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" [id=262, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" [id=263, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]", style=filled, type=hardtanh]; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=264, label="8_bit__AFQ_#2", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"265 MobileNetV2/adaptive_avg_pool2d" [id=265, label=adaptive_avg_pool2d, scope=MobileNetV2, style=filled, type=adaptive_avg_pool2d]; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#53", scope="MobileNetV2/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" [id=267, label=dropout, scope="MobileNetV2/Sequential[classifier]/Dropout[0]", style=filled, type=dropout]; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=268, label="2_bit__WFQ_#53", scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear" [id=269, label=linear, scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" -> "14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm"; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize"; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" -> "45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize"; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize"; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" -> "121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" -> "137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" -> "153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize"; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" -> "183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize"; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" -> "245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize"; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" -> "262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm"; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" -> "263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh"; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" -> "264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "265 MobileNetV2/adaptive_avg_pool2d"; +"265 MobileNetV2/adaptive_avg_pool2d" -> "266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize"; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" -> "267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout"; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__setup_type_propagation_based.dot new file mode 100644 index 00000000000..ceb32a1ef46 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/mobilenet_v2_device_VPU__setup_type_propagation_based.dot @@ -0,0 +1,551 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=4, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=5, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#1", scope="MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=7, label="8_bit__WFQ_#1", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=purple, id=8, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=9, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=10, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=11, label="4_bit__AFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=12, label="8_bit__WFQ_#29", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" [color=lightblue, id=13, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]", style=filled, type=conv2d]; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" [id=14, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]", style=filled, type=batch_norm]; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=15, label="4_bit__AFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=16, label="8_bit__WFQ_#28", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=17, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=18, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=19, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=20, label="8_bit__AFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=21, label="8_bit__WFQ_#31", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=22, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=23, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=24, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=26, label="8_bit__WFQ_#32", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=27, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=28, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=29, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=30, label="8_bit__WFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=31, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=32, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=33, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=34, label="8_bit__AFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=35, label="8_bit__WFQ_#33", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=36, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=37, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=38, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=39, label="4_bit__AFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=40, label="4_bit__WFQ_#34", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=41, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=42, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=43, label="8_bit__AFQ_#30", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" [id=44, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[3]", style=filled, type=__add__]; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#35", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=47, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=48, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=49, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=50, label="8_bit__AFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#37", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=52, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=53, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=54, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=55, label="4_bit__AFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=56, label="4_bit__WFQ_#38", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=57, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=58, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=59, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=60, label="8_bit__WFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=61, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=62, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=63, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=64, label="8_bit__AFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=65, label="8_bit__WFQ_#39", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=66, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=67, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=68, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=69, label="8_bit__AFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=70, label="4_bit__WFQ_#40", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=71, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=72, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=73, label="4_bit__AFQ_#36", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" [id=74, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[5]", style=filled, type=__add__]; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=75, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=76, label="8_bit__WFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=77, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=78, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=79, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=80, label="8_bit__AFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=81, label="8_bit__WFQ_#42", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=82, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=83, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=84, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=85, label="8_bit__AFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=86, label="8_bit__WFQ_#43", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=87, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=88, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=89, label="8_bit__AFQ_#41", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" [id=90, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[6]", style=filled, type=__add__]; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=91, label="4_bit__AFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=92, label="4_bit__WFQ_#44", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=93, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=94, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=95, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=96, label="8_bit__AFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=97, label="8_bit__WFQ_#46", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=98, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=99, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=100, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=101, label="8_bit__AFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=102, label="4_bit__WFQ_#47", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=103, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=104, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=106, label="4_bit__WFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=107, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=108, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=109, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=111, label="8_bit__WFQ_#48", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=112, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=113, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=114, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=115, label="8_bit__AFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=116, label="8_bit__WFQ_#49", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=117, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=118, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=119, label="8_bit__AFQ_#45", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" [id=120, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[8]", style=filled, type=__add__]; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=121, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=122, label="4_bit__WFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=123, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=124, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=125, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=126, label="8_bit__AFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=127, label="8_bit__WFQ_#51", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=128, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=129, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=130, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=131, label="4_bit__AFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=132, label="8_bit__WFQ_#52", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=133, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=134, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=135, label="4_bit__AFQ_#50", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" [id=136, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[9]", style=filled, type=__add__]; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=137, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=138, label="8_bit__WFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=139, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=140, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=141, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=142, label="8_bit__AFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=143, label="2_bit__WFQ_#4", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=144, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=145, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=146, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=147, label="4_bit__AFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=148, label="8_bit__WFQ_#5", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=149, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=150, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=151, label="4_bit__AFQ_#3", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" [id=152, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[10]", style=filled, type=__add__]; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=153, label="8_bit__AFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=154, label="8_bit__WFQ_#6", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=155, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=156, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=157, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=158, label="8_bit__AFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=159, label="4_bit__WFQ_#8", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=160, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=161, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=162, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=163, label="4_bit__AFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=164, label="8_bit__WFQ_#9", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=165, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=166, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=167, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=168, label="4_bit__WFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=169, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=170, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=171, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=172, label="8_bit__AFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=173, label="2_bit__WFQ_#10", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=174, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=175, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=176, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#11", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=180, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=181, label="4_bit__AFQ_#7", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" [id=182, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[12]", style=filled, type=__add__]; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=183, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=184, label="8_bit__WFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=185, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=186, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=187, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=188, label="8_bit__AFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=189, label="8_bit__WFQ_#13", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=190, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=191, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=192, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=193, label="8_bit__AFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=194, label="8_bit__WFQ_#14", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=195, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=196, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=197, label="8_bit__AFQ_#12", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" [id=198, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[13]", style=filled, type=__add__]; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=200, label="8_bit__WFQ_#15", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=201, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=202, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=203, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=204, label="8_bit__AFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=205, label="4_bit__WFQ_#17", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=206, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=207, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=208, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=209, label="4_bit__AFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=210, label="4_bit__WFQ_#18", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=211, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=212, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=213, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=214, label="8_bit__WFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=215, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=216, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=217, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=218, label="8_bit__AFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=219, label="4_bit__WFQ_#19", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=220, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=221, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=222, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=224, label="4_bit__WFQ_#20", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=225, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=226, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=227, label="8_bit__AFQ_#16", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" [id=228, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[15]", style=filled, type=__add__]; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=229, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=230, label="4_bit__WFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=231, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=232, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=233, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=234, label="8_bit__AFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=235, label="4_bit__WFQ_#22", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=236, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=237, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=238, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=239, label="4_bit__AFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=240, label="2_bit__WFQ_#23", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=241, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=242, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=243, label="4_bit__AFQ_#21", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" [id=244, label=__add__, scope="MobileNetV2/Sequential[features]/InvertedResidual[16]", style=filled, type=__add__]; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=245, label="4_bit__AFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#24", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" [color=lightblue, id=247, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]", style=filled, type=conv2d]; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" [id=248, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" [id=249, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]", style=filled, type=hardtanh]; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=250, label="8_bit__AFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#26", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" [color=purple, id=252, label=DW_Conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]", style=filled, type=conv2d]; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" [id=253, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" [id=254, label=hardtanh, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]", style=filled, type=hardtanh]; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=255, label="8_bit__AFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=256, label="8_bit__WFQ_#27", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" [color=lightblue, id=257, label=conv2d, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]", style=filled, type=conv2d]; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" [id=258, label=batch_norm, scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]", style=filled, type=batch_norm]; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=259, label="4_bit__AFQ_#25", scope="MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=260, label="4_bit__WFQ_#25", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" [color=lightblue, id=261, label=conv2d, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]", style=filled, type=conv2d]; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" [id=262, label=batch_norm, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" [id=263, label=hardtanh, scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]", style=filled, type=hardtanh]; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=264, label="8_bit__AFQ_#2", scope="MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"265 MobileNetV2/adaptive_avg_pool2d" [id=265, label=adaptive_avg_pool2d, scope=MobileNetV2, style=filled, type=adaptive_avg_pool2d]; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#53", scope="MobileNetV2/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" [id=267, label=dropout, scope="MobileNetV2/Sequential[classifier]/Dropout[0]", style=filled, type=dropout]; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=268, label="2_bit__WFQ_#53", scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear" [id=269, label=linear, scope="MobileNetV2/Sequential[classifier]/NNCFLinear[1]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"2 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"3 MobileNetV2/Sequential[features]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"4 MobileNetV2/Sequential[features]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"5 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"6 MobileNetV2/Sequential[features]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"7 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"8 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"9 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"10 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"11 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"12 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d"; +"13 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/NNCFConv2d[1]/conv2d" -> "14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm"; +"14 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/batch_norm" -> "15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize"; +"15 MobileNetV2/Sequential[features]/InvertedResidual[1]/Sequential[conv]/BatchNorm2d[2]/AsymmetricQuantizer/asymmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"16 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"17 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"18 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"19 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"20 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"21 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"22 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"23 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"24 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"25 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"26 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"27 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"28 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"29 MobileNetV2/Sequential[features]/InvertedResidual[2]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"30 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"31 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"32 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"33 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"34 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"35 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"36 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"37 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"38 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"39 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"40 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"41 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"42 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"43 MobileNetV2/Sequential[features]/InvertedResidual[3]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__"; +"44 MobileNetV2/Sequential[features]/InvertedResidual[3]/__add__" -> "45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize"; +"45 MobileNetV2/Sequential[features]/InvertedResidual[3]/AsymmetricQuantizer/asymmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"46 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"47 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"48 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"49 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"50 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"51 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"52 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"53 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"54 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"55 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"56 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"57 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"58 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"59 MobileNetV2/Sequential[features]/InvertedResidual[4]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"60 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"61 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"62 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"63 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"64 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"65 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"66 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"67 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"68 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"69 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"70 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"71 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"72 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"73 MobileNetV2/Sequential[features]/InvertedResidual[5]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__"; +"74 MobileNetV2/Sequential[features]/InvertedResidual[5]/__add__" -> "75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"75 MobileNetV2/Sequential[features]/InvertedResidual[5]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"76 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"77 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"78 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"79 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"80 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"81 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"82 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"83 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"84 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"85 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"86 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"87 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"88 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"89 MobileNetV2/Sequential[features]/InvertedResidual[6]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__"; +"90 MobileNetV2/Sequential[features]/InvertedResidual[6]/__add__" -> "91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize"; +"91 MobileNetV2/Sequential[features]/InvertedResidual[6]/AsymmetricQuantizer/asymmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"92 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"93 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"94 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"95 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"96 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"97 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"98 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"99 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"100 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"101 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"102 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"103 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"104 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"105 MobileNetV2/Sequential[features]/InvertedResidual[7]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"106 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"107 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"108 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"109 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"110 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"111 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"112 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"113 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"114 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"115 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"116 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"117 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"118 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"119 MobileNetV2/Sequential[features]/InvertedResidual[8]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__"; +"120 MobileNetV2/Sequential[features]/InvertedResidual[8]/__add__" -> "121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"121 MobileNetV2/Sequential[features]/InvertedResidual[8]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"122 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"123 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"124 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"125 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"126 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"127 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"128 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"129 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"130 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"131 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"132 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"133 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"134 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"135 MobileNetV2/Sequential[features]/InvertedResidual[9]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__"; +"136 MobileNetV2/Sequential[features]/InvertedResidual[9]/__add__" -> "137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"137 MobileNetV2/Sequential[features]/InvertedResidual[9]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"138 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"139 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"140 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"141 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"142 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"143 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"144 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"145 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"146 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"147 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"148 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"149 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"150 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"151 MobileNetV2/Sequential[features]/InvertedResidual[10]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__"; +"152 MobileNetV2/Sequential[features]/InvertedResidual[10]/__add__" -> "153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize"; +"153 MobileNetV2/Sequential[features]/InvertedResidual[10]/AsymmetricQuantizer/asymmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"154 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"155 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"156 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"157 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"158 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"159 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"160 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"161 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"162 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"163 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"164 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"165 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"166 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"167 MobileNetV2/Sequential[features]/InvertedResidual[11]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"168 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"169 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"170 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"171 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"172 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"173 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"174 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"175 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"176 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"177 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"178 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"179 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"180 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"181 MobileNetV2/Sequential[features]/InvertedResidual[12]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__"; +"182 MobileNetV2/Sequential[features]/InvertedResidual[12]/__add__" -> "183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"183 MobileNetV2/Sequential[features]/InvertedResidual[12]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"184 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"185 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"186 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"187 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"188 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"189 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"190 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"191 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"192 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"193 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"194 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"195 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"196 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"197 MobileNetV2/Sequential[features]/InvertedResidual[13]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__"; +"198 MobileNetV2/Sequential[features]/InvertedResidual[13]/__add__" -> "199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize"; +"199 MobileNetV2/Sequential[features]/InvertedResidual[13]/AsymmetricQuantizer/asymmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"200 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"201 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"202 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"203 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"204 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"205 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"206 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"207 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"208 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"209 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"210 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"211 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"212 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"213 MobileNetV2/Sequential[features]/InvertedResidual[14]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"214 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"215 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"216 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"217 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"218 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"219 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"220 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"221 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"222 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"223 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"224 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"225 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"226 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"227 MobileNetV2/Sequential[features]/InvertedResidual[15]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__"; +"228 MobileNetV2/Sequential[features]/InvertedResidual[15]/__add__" -> "229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"229 MobileNetV2/Sequential[features]/InvertedResidual[15]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"230 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"231 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"232 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"233 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"234 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"235 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"236 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"237 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"238 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"239 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"240 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"241 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"242 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"243 MobileNetV2/Sequential[features]/InvertedResidual[16]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__"; +"244 MobileNetV2/Sequential[features]/InvertedResidual[16]/__add__" -> "245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize"; +"245 MobileNetV2/Sequential[features]/InvertedResidual[16]/AsymmetricQuantizer/asymmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"246 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d"; +"247 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/NNCFConv2d[0]/conv2d" -> "248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm"; +"248 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/BatchNorm2d[1]/batch_norm" -> "249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh"; +"249 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/hardtanh" -> "250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"250 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[0]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"251 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d"; +"252 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/NNCFConv2d[0]/conv2d" -> "253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm"; +"253 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/BatchNorm2d[1]/batch_norm" -> "254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh"; +"254 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/hardtanh" -> "255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize"; +"255 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/ConvBNReLU[1]/ReLU6[2]/AsymmetricQuantizer/asymmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"256 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d"; +"257 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/NNCFConv2d[2]/conv2d" -> "258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm"; +"258 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/batch_norm" -> "259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize"; +"259 MobileNetV2/Sequential[features]/InvertedResidual[17]/Sequential[conv]/BatchNorm2d[3]/AsymmetricQuantizer/asymmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"260 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d"; +"261 MobileNetV2/Sequential[features]/ConvBNReLU[18]/NNCFConv2d[0]/conv2d" -> "262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm"; +"262 MobileNetV2/Sequential[features]/ConvBNReLU[18]/BatchNorm2d[1]/batch_norm" -> "263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh"; +"263 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/hardtanh" -> "264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize"; +"264 MobileNetV2/Sequential[features]/ConvBNReLU[18]/ReLU6[2]/SymmetricQuantizer/symmetric_quantize" -> "265 MobileNetV2/adaptive_avg_pool2d"; +"265 MobileNetV2/adaptive_avg_pool2d" -> "266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize"; +"266 MobileNetV2/AsymmetricQuantizer/asymmetric_quantize" -> "267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout"; +"267 MobileNetV2/Sequential[classifier]/Dropout[0]/dropout" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +"268 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "269 MobileNetV2/Sequential[classifier]/NNCFLinear[1]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__eval_subset_ratio_0.4__ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__eval_subset_ratio_0.4__ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..b669ad92cf4 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__eval_subset_ratio_0.4__ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,617 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 ResNet/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=3, label=conv2d, scope="ResNet/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" [id=4, label=batch_norm, scope="ResNet/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"5 ResNet/ReLU[relu]/RELU" [id=5, label=RELU, scope="ResNet/ReLU[relu]", style=filled, type=RELU]; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=6, label="4_bit__AFQ_#2", scope="ResNet/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" [id=7, label=max_pool2d, scope="ResNet/MaxPool2d[maxpool]", style=filled, type=max_pool2d]; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=8, label="8_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=9, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=10, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=11, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=12, label="4_bit__AFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=13, label="4_bit__WFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=14, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=15, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=16, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=17, label="8_bit__AFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=18, label="4_bit__WFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=19, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=20, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=21, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=22, label="4_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=23, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=24, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" [id=26, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[0]", style=filled, type=__iadd__]; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=27, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=28, label="4_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=29, label="4_bit__WFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=30, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=31, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=32, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=33, label="8_bit__AFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=34, label="8_bit__WFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=35, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=36, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=37, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=38, label="8_bit__AFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=39, label="8_bit__WFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=40, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=41, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=42, label="8_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" [id=43, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[1]", style=filled, type=__iadd__]; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=44, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=47, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=48, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=49, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=51, label="4_bit__WFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=52, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=53, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=54, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=55, label="8_bit__AFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=56, label="8_bit__WFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=57, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=58, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=59, label="8_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" [id=60, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[2]", style=filled, type=__iadd__]; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=61, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=62, label="4_bit__AFQ_#12", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=63, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=64, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=65, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=66, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=67, label="8_bit__AFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=68, label="8_bit__WFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=69, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=70, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=71, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=72, label="4_bit__AFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=73, label="8_bit__WFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=74, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=75, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=76, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=77, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=78, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=79, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=80, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" [id=81, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[0]", style=filled, type=__iadd__]; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=82, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=84, label="8_bit__WFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=85, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=86, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=87, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=88, label="8_bit__AFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=89, label="8_bit__WFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=90, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=91, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=92, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=93, label="4_bit__AFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=94, label="2_bit__WFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=95, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=96, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=97, label="8_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" [id=98, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[1]", style=filled, type=__iadd__]; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=99, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=100, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=101, label="8_bit__WFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=102, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=103, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=104, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=106, label="8_bit__WFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=107, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=108, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=109, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=111, label="2_bit__WFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=112, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=113, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=114, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" [id=115, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[2]", style=filled, type=__iadd__]; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=116, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=117, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=118, label="4_bit__WFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=119, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=120, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=121, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=122, label="8_bit__AFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=123, label="2_bit__WFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=124, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=125, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=126, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=127, label="4_bit__AFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=128, label="2_bit__WFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=129, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=130, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=131, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" [id=132, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[3]", style=filled, type=__iadd__]; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=133, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=134, label="4_bit__AFQ_#25", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=135, label="4_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=136, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=137, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=138, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=139, label="8_bit__AFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=140, label="8_bit__WFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=141, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=142, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=143, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=144, label="4_bit__AFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=145, label="4_bit__WFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=146, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=147, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=148, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=149, label="8_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=150, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=151, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=152, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" [id=153, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[0]", style=filled, type=__iadd__]; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=154, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=155, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=156, label="8_bit__WFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=157, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=158, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=159, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=160, label="8_bit__AFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=161, label="8_bit__WFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=162, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=163, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=164, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=165, label="8_bit__AFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=166, label="8_bit__WFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=167, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=168, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=169, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" [id=170, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[1]", style=filled, type=__iadd__]; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=171, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=172, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=173, label="4_bit__WFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=174, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=175, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=176, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=180, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=181, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=182, label="8_bit__AFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=183, label="4_bit__WFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=184, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=185, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=186, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" [id=187, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[2]", style=filled, type=__iadd__]; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=188, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=189, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=190, label="2_bit__WFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=191, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=192, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=193, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=194, label="4_bit__AFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=195, label="4_bit__WFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=196, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=197, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=198, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=200, label="4_bit__WFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=201, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=202, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=203, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" [id=204, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[3]", style=filled, type=__iadd__]; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=205, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=206, label="4_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=207, label="2_bit__WFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=208, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" [id=209, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=210, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=211, label="8_bit__AFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=212, label="4_bit__WFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=213, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" [id=214, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=215, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=216, label="8_bit__AFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=217, label="8_bit__WFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=218, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" [id=219, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=220, label="8_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" [id=221, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[4]", style=filled, type=__iadd__]; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=222, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=224, label="8_bit__WFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=225, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" [id=226, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=227, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=228, label="4_bit__AFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=229, label="2_bit__WFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=230, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" [id=231, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=232, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=233, label="8_bit__AFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=234, label="4_bit__WFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=235, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" [id=236, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=237, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" [id=238, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[5]", style=filled, type=__iadd__]; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=239, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=240, label="8_bit__AFQ_#44", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=241, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=242, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=243, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=244, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=245, label="8_bit__AFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=247, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=248, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=249, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=250, label="4_bit__AFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=252, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=253, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=254, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=255, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=256, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=257, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=258, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" [id=259, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[0]", style=filled, type=__iadd__]; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=260, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=261, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=262, label="4_bit__WFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=263, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=264, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=265, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=267, label="8_bit__WFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=268, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=269, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=270, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=271, label="4_bit__AFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=272, label="4_bit__WFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=273, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=274, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=275, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" [id=276, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[1]", style=filled, type=__iadd__]; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=277, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=278, label="4_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=279, label="4_bit__WFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=280, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=281, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=282, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=283, label="4_bit__AFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=284, label="4_bit__WFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=285, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=286, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=287, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=288, label="4_bit__AFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=289, label="4_bit__WFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=290, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=291, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=292, label="8_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" [id=293, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[2]", style=filled, type=__iadd__]; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=294, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" [color=green, id=295, label="8_bit__AFQ_#54", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=296, label=adaptive_avg_pool2d, scope="ResNet/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=297, label="4_bit__AFQ_#1", scope="ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=298, label="8_bit__WFQ_#1", scope="ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"299 ResNet/NNCFLinear[fc]/linear" [id=299, label=linear, scope="ResNet/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"3 ResNet/NNCFConv2d[conv1]/conv2d" -> "4 ResNet/BatchNorm2d[bn1]/batch_norm"; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" -> "5 ResNet/ReLU[relu]/RELU"; +"5 ResNet/ReLU[relu]/RELU" -> "6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" -> "27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" -> "44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" -> "61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" -> "82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" -> "99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" -> "116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" -> "133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" -> "154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" -> "171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" -> "188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" -> "205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm"; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" -> "210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" -> "214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm"; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" -> "215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" -> "219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm"; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" -> "220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" -> "222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" -> "226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm"; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" -> "227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" -> "231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm"; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" -> "232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" -> "236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm"; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" -> "237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" -> "239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" -> "260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" -> "277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" -> "294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize"; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" -> "296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..27919856bfa --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,617 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 ResNet/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=3, label=conv2d, scope="ResNet/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" [id=4, label=batch_norm, scope="ResNet/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"5 ResNet/ReLU[relu]/RELU" [id=5, label=RELU, scope="ResNet/ReLU[relu]", style=filled, type=RELU]; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=6, label="4_bit__AFQ_#2", scope="ResNet/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" [id=7, label=max_pool2d, scope="ResNet/MaxPool2d[maxpool]", style=filled, type=max_pool2d]; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=8, label="8_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=9, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=10, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=11, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=12, label="4_bit__AFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=13, label="4_bit__WFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=14, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=15, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=16, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=17, label="8_bit__AFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=18, label="4_bit__WFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=19, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=20, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=21, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=22, label="4_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=23, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=24, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" [id=26, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[0]", style=filled, type=__iadd__]; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=27, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=28, label="4_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=29, label="4_bit__WFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=30, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=31, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=32, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=33, label="8_bit__AFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=34, label="8_bit__WFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=35, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=36, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=37, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=38, label="8_bit__AFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=39, label="8_bit__WFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=40, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=41, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=42, label="8_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" [id=43, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[1]", style=filled, type=__iadd__]; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=44, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=47, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=48, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=49, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=51, label="4_bit__WFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=52, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=53, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=54, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=55, label="8_bit__AFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=56, label="8_bit__WFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=57, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=58, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=59, label="8_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" [id=60, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[2]", style=filled, type=__iadd__]; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=61, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=62, label="4_bit__AFQ_#12", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=63, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=64, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=65, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=66, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=67, label="8_bit__AFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=68, label="8_bit__WFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=69, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=70, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=71, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=72, label="4_bit__AFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=73, label="8_bit__WFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=74, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=75, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=76, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=77, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=78, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=79, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=80, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" [id=81, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[0]", style=filled, type=__iadd__]; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=82, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=84, label="8_bit__WFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=85, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=86, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=87, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=88, label="8_bit__AFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=89, label="8_bit__WFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=90, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=91, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=92, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=93, label="4_bit__AFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=94, label="2_bit__WFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=95, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=96, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=97, label="8_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" [id=98, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[1]", style=filled, type=__iadd__]; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=99, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=100, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=101, label="8_bit__WFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=102, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=103, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=104, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=106, label="8_bit__WFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=107, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=108, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=109, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=111, label="2_bit__WFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=112, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=113, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=114, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" [id=115, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[2]", style=filled, type=__iadd__]; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=116, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=117, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=118, label="4_bit__WFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=119, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=120, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=121, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=122, label="8_bit__AFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=123, label="2_bit__WFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=124, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=125, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=126, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=127, label="4_bit__AFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=128, label="2_bit__WFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=129, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=130, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=131, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" [id=132, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[3]", style=filled, type=__iadd__]; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=133, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=134, label="4_bit__AFQ_#25", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=135, label="4_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=136, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=137, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=138, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=139, label="8_bit__AFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=140, label="8_bit__WFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=141, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=142, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=143, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=144, label="4_bit__AFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=145, label="4_bit__WFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=146, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=147, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=148, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=149, label="8_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=150, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=151, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=152, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" [id=153, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[0]", style=filled, type=__iadd__]; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=154, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=155, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=156, label="8_bit__WFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=157, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=158, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=159, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=160, label="8_bit__AFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=161, label="8_bit__WFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=162, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=163, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=164, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=165, label="8_bit__AFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=166, label="8_bit__WFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=167, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=168, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=169, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" [id=170, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[1]", style=filled, type=__iadd__]; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=171, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=172, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=173, label="4_bit__WFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=174, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=175, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=176, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=180, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=181, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=182, label="8_bit__AFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=183, label="4_bit__WFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=184, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=185, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=186, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" [id=187, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[2]", style=filled, type=__iadd__]; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=188, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=189, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=190, label="2_bit__WFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=191, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=192, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=193, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=194, label="4_bit__AFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=195, label="4_bit__WFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=196, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=197, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=198, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=200, label="4_bit__WFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=201, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=202, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=203, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" [id=204, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[3]", style=filled, type=__iadd__]; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=205, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=206, label="4_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=207, label="2_bit__WFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=208, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" [id=209, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=210, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=211, label="8_bit__AFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=212, label="4_bit__WFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=213, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" [id=214, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=215, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=216, label="8_bit__AFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=217, label="8_bit__WFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=218, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" [id=219, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=220, label="8_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" [id=221, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[4]", style=filled, type=__iadd__]; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=222, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=224, label="8_bit__WFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=225, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" [id=226, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=227, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=228, label="4_bit__AFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=229, label="2_bit__WFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=230, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" [id=231, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=232, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=233, label="8_bit__AFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=234, label="4_bit__WFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=235, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" [id=236, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=237, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" [id=238, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[5]", style=filled, type=__iadd__]; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=239, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=240, label="8_bit__AFQ_#44", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=241, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=242, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=243, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=244, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=245, label="8_bit__AFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=247, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=248, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=249, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=250, label="4_bit__AFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=252, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=253, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=254, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=255, label="4_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=256, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=257, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=258, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" [id=259, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[0]", style=filled, type=__iadd__]; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=260, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=261, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=262, label="2_bit__WFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=263, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=264, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=265, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=267, label="4_bit__WFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=268, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=269, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=270, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=271, label="4_bit__AFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=272, label="2_bit__WFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=273, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=274, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=275, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" [id=276, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[1]", style=filled, type=__iadd__]; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=277, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=278, label="4_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=279, label="2_bit__WFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=280, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=281, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=282, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=283, label="4_bit__AFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=284, label="2_bit__WFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=285, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=286, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=287, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=288, label="4_bit__AFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=289, label="2_bit__WFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=290, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=291, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=292, label="8_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" [id=293, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[2]", style=filled, type=__iadd__]; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=294, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" [color=green, id=295, label="8_bit__AFQ_#54", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=296, label=adaptive_avg_pool2d, scope="ResNet/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=297, label="4_bit__AFQ_#1", scope="ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=298, label="4_bit__WFQ_#1", scope="ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"299 ResNet/NNCFLinear[fc]/linear" [id=299, label=linear, scope="ResNet/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"3 ResNet/NNCFConv2d[conv1]/conv2d" -> "4 ResNet/BatchNorm2d[bn1]/batch_norm"; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" -> "5 ResNet/ReLU[relu]/RELU"; +"5 ResNet/ReLU[relu]/RELU" -> "6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" -> "27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" -> "44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" -> "61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" -> "82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" -> "99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" -> "116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" -> "133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" -> "154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" -> "171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" -> "188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" -> "205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm"; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" -> "210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" -> "214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm"; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" -> "215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" -> "219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm"; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" -> "220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" -> "222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" -> "226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm"; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" -> "227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" -> "231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm"; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" -> "232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" -> "236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm"; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" -> "237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" -> "239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" -> "260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" -> "277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" -> "294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize"; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" -> "296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__iter_number_4__setup_type_propagation_based__warmup_iter_number_2.dot b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__iter_number_4__setup_type_propagation_based__warmup_iter_number_2.dot new file mode 100644 index 00000000000..4a27aec071d --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__iter_number_4__setup_type_propagation_based__warmup_iter_number_2.dot @@ -0,0 +1,617 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=2, label="4_bit__WFQ_#0", scope="ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 ResNet/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=3, label=conv2d, scope="ResNet/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" [id=4, label=batch_norm, scope="ResNet/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"5 ResNet/ReLU[relu]/RELU" [id=5, label=RELU, scope="ResNet/ReLU[relu]", style=filled, type=RELU]; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=6, label="8_bit__AFQ_#2", scope="ResNet/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" [id=7, label=max_pool2d, scope="ResNet/MaxPool2d[maxpool]", style=filled, type=max_pool2d]; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=8, label="8_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=9, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=10, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=11, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=12, label="8_bit__AFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=13, label="4_bit__WFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=14, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=15, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=16, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=17, label="8_bit__AFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=18, label="8_bit__WFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=19, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=20, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=21, label="4_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=22, label="4_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=23, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=24, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=25, label="4_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" [id=26, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[0]", style=filled, type=__iadd__]; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=27, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=28, label="8_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=29, label="8_bit__WFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=30, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=31, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=32, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=33, label="4_bit__AFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=34, label="8_bit__WFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=35, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=36, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=37, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=38, label="8_bit__AFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=39, label="8_bit__WFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=40, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=41, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=42, label="8_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" [id=43, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[1]", style=filled, type=__iadd__]; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=44, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=45, label="8_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=47, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=48, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=49, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=50, label="8_bit__AFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=52, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=53, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=54, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=55, label="4_bit__AFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=56, label="8_bit__WFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=57, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=58, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=59, label="4_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" [id=60, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[2]", style=filled, type=__iadd__]; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=61, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=62, label="4_bit__AFQ_#12", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=63, label="4_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=64, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=65, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=66, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=67, label="4_bit__AFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=68, label="8_bit__WFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=69, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=70, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=71, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=72, label="4_bit__AFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=73, label="8_bit__WFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=74, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=75, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=76, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=77, label="4_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=78, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=79, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=80, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" [id=81, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[0]", style=filled, type=__iadd__]; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=82, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=84, label="4_bit__WFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=85, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=86, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=87, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=88, label="4_bit__AFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=89, label="8_bit__WFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=90, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=91, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=92, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=93, label="4_bit__AFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=94, label="8_bit__WFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=95, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=96, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=97, label="8_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" [id=98, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[1]", style=filled, type=__iadd__]; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=99, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=100, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=101, label="4_bit__WFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=102, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=103, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=104, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=105, label="4_bit__AFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=106, label="8_bit__WFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=107, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=108, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=109, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=110, label="4_bit__AFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=111, label="2_bit__WFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=112, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=113, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=114, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" [id=115, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[2]", style=filled, type=__iadd__]; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=116, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=117, label="4_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=118, label="4_bit__WFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=119, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=120, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=121, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=122, label="4_bit__AFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=123, label="4_bit__WFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=124, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=125, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=126, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=127, label="4_bit__AFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=128, label="2_bit__WFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=129, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=130, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=131, label="4_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" [id=132, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[3]", style=filled, type=__iadd__]; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=133, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=134, label="8_bit__AFQ_#25", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=135, label="8_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=136, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=137, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=138, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=139, label="8_bit__AFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=140, label="4_bit__WFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=141, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=142, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=143, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=144, label="4_bit__AFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=145, label="8_bit__WFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=146, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=147, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=148, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=149, label="8_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=150, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=151, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=152, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" [id=153, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[0]", style=filled, type=__iadd__]; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=154, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=155, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=156, label="8_bit__WFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=157, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=158, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=159, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=160, label="4_bit__AFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=161, label="4_bit__WFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=162, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=163, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=164, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=165, label="8_bit__AFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=166, label="4_bit__WFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=167, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=168, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=169, label="8_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" [id=170, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[1]", style=filled, type=__iadd__]; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=171, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=172, label="8_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=173, label="4_bit__WFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=174, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=175, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=176, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=177, label="8_bit__AFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=178, label="4_bit__WFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=180, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=181, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=182, label="8_bit__AFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=183, label="4_bit__WFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=184, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=185, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=186, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" [id=187, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[2]", style=filled, type=__iadd__]; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=188, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=189, label="8_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=190, label="8_bit__WFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=191, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=192, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=193, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=194, label="4_bit__AFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=195, label="4_bit__WFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=196, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=197, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=198, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=199, label="4_bit__AFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=200, label="8_bit__WFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=201, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=202, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=203, label="8_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" [id=204, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[3]", style=filled, type=__iadd__]; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=205, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=206, label="8_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=207, label="8_bit__WFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=208, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" [id=209, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=210, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=211, label="4_bit__AFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=212, label="8_bit__WFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=213, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" [id=214, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=215, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=216, label="4_bit__AFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=217, label="4_bit__WFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=218, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" [id=219, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=220, label="8_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" [id=221, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[4]", style=filled, type=__iadd__]; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=222, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=224, label="8_bit__WFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=225, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" [id=226, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=227, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=228, label="4_bit__AFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=229, label="8_bit__WFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=230, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" [id=231, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=232, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=233, label="8_bit__AFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=234, label="4_bit__WFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=235, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" [id=236, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=237, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" [id=238, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[5]", style=filled, type=__iadd__]; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=239, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=240, label="4_bit__AFQ_#44", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=241, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=242, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=243, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=244, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=245, label="4_bit__AFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=246, label="4_bit__WFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=247, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=248, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=249, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=250, label="4_bit__AFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=251, label="4_bit__WFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=252, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=253, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=254, label="8_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=255, label="4_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=256, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=257, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=258, label="8_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" [id=259, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[0]", style=filled, type=__iadd__]; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=260, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=261, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=262, label="8_bit__WFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=263, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=264, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=265, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=267, label="4_bit__WFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=268, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=269, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=270, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=271, label="8_bit__AFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=272, label="4_bit__WFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=273, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=274, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=275, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" [id=276, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[1]", style=filled, type=__iadd__]; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=277, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=278, label="8_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=279, label="4_bit__WFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=280, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=281, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=282, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=283, label="4_bit__AFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=284, label="2_bit__WFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=285, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=286, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=287, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=288, label="4_bit__AFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=289, label="2_bit__WFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=290, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=291, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=292, label="4_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" [id=293, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[2]", style=filled, type=__iadd__]; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=294, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" [color=green, id=295, label="8_bit__AFQ_#54", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=296, label=adaptive_avg_pool2d, scope="ResNet/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=297, label="8_bit__AFQ_#1", scope="ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=298, label="2_bit__WFQ_#1", scope="ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"299 ResNet/NNCFLinear[fc]/linear" [id=299, label=linear, scope="ResNet/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"3 ResNet/NNCFConv2d[conv1]/conv2d" -> "4 ResNet/BatchNorm2d[bn1]/batch_norm"; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" -> "5 ResNet/ReLU[relu]/RELU"; +"5 ResNet/ReLU[relu]/RELU" -> "6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" -> "27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" -> "44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" -> "61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" -> "82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" -> "99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" -> "116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" -> "133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" -> "154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" -> "171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" -> "188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" -> "205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm"; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" -> "210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" -> "214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm"; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" -> "215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" -> "219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm"; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" -> "220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" -> "222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" -> "226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm"; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" -> "227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" -> "231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm"; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" -> "232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" -> "236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm"; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" -> "237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" -> "239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" -> "260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" -> "277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" -> "294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize"; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" -> "296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..b669ad92cf4 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,617 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 ResNet/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=3, label=conv2d, scope="ResNet/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" [id=4, label=batch_norm, scope="ResNet/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"5 ResNet/ReLU[relu]/RELU" [id=5, label=RELU, scope="ResNet/ReLU[relu]", style=filled, type=RELU]; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=6, label="4_bit__AFQ_#2", scope="ResNet/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" [id=7, label=max_pool2d, scope="ResNet/MaxPool2d[maxpool]", style=filled, type=max_pool2d]; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=8, label="8_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=9, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=10, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=11, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=12, label="4_bit__AFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=13, label="4_bit__WFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=14, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=15, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=16, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=17, label="8_bit__AFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=18, label="4_bit__WFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=19, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=20, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=21, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=22, label="4_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=23, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=24, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" [id=26, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[0]", style=filled, type=__iadd__]; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=27, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=28, label="4_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=29, label="4_bit__WFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=30, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=31, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=32, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=33, label="8_bit__AFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=34, label="8_bit__WFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=35, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=36, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=37, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=38, label="8_bit__AFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=39, label="8_bit__WFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=40, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=41, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=42, label="8_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" [id=43, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[1]", style=filled, type=__iadd__]; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=44, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=47, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=48, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=49, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=51, label="4_bit__WFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=52, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=53, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=54, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=55, label="8_bit__AFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=56, label="8_bit__WFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=57, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=58, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=59, label="8_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" [id=60, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[2]", style=filled, type=__iadd__]; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=61, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=62, label="4_bit__AFQ_#12", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=63, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=64, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=65, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=66, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=67, label="8_bit__AFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=68, label="8_bit__WFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=69, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=70, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=71, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=72, label="4_bit__AFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=73, label="8_bit__WFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=74, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=75, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=76, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=77, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=78, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=79, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=80, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" [id=81, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[0]", style=filled, type=__iadd__]; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=82, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=84, label="8_bit__WFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=85, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=86, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=87, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=88, label="8_bit__AFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=89, label="8_bit__WFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=90, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=91, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=92, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=93, label="4_bit__AFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=94, label="2_bit__WFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=95, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=96, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=97, label="8_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" [id=98, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[1]", style=filled, type=__iadd__]; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=99, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=100, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=101, label="8_bit__WFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=102, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=103, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=104, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=106, label="8_bit__WFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=107, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=108, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=109, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=111, label="2_bit__WFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=112, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=113, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=114, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" [id=115, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[2]", style=filled, type=__iadd__]; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=116, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=117, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=118, label="4_bit__WFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=119, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=120, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=121, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=122, label="8_bit__AFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=123, label="2_bit__WFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=124, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=125, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=126, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=127, label="4_bit__AFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=128, label="2_bit__WFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=129, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=130, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=131, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" [id=132, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[3]", style=filled, type=__iadd__]; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=133, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=134, label="4_bit__AFQ_#25", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=135, label="4_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=136, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=137, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=138, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=139, label="8_bit__AFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=140, label="8_bit__WFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=141, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=142, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=143, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=144, label="4_bit__AFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=145, label="4_bit__WFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=146, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=147, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=148, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=149, label="8_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=150, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=151, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=152, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" [id=153, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[0]", style=filled, type=__iadd__]; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=154, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=155, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=156, label="8_bit__WFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=157, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=158, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=159, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=160, label="8_bit__AFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=161, label="8_bit__WFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=162, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=163, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=164, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=165, label="8_bit__AFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=166, label="8_bit__WFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=167, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=168, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=169, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" [id=170, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[1]", style=filled, type=__iadd__]; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=171, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=172, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=173, label="4_bit__WFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=174, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=175, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=176, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=180, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=181, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=182, label="8_bit__AFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=183, label="4_bit__WFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=184, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=185, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=186, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" [id=187, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[2]", style=filled, type=__iadd__]; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=188, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=189, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=190, label="2_bit__WFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=191, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=192, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=193, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=194, label="4_bit__AFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=195, label="4_bit__WFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=196, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=197, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=198, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=200, label="4_bit__WFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=201, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=202, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=203, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" [id=204, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[3]", style=filled, type=__iadd__]; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=205, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=206, label="4_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=207, label="2_bit__WFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=208, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" [id=209, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=210, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=211, label="8_bit__AFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=212, label="4_bit__WFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=213, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" [id=214, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=215, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=216, label="8_bit__AFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=217, label="8_bit__WFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=218, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" [id=219, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=220, label="8_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" [id=221, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[4]", style=filled, type=__iadd__]; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=222, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=224, label="8_bit__WFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=225, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" [id=226, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=227, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=228, label="4_bit__AFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=229, label="2_bit__WFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=230, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" [id=231, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=232, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=233, label="8_bit__AFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=234, label="4_bit__WFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=235, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" [id=236, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=237, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" [id=238, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[5]", style=filled, type=__iadd__]; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=239, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=240, label="8_bit__AFQ_#44", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=241, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=242, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=243, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=244, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=245, label="8_bit__AFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=247, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=248, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=249, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=250, label="4_bit__AFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=252, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=253, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=254, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=255, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=256, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=257, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=258, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" [id=259, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[0]", style=filled, type=__iadd__]; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=260, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=261, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=262, label="4_bit__WFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=263, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=264, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=265, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=267, label="8_bit__WFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=268, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=269, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=270, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=271, label="4_bit__AFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=272, label="4_bit__WFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=273, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=274, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=275, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" [id=276, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[1]", style=filled, type=__iadd__]; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=277, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=278, label="4_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=279, label="4_bit__WFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=280, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=281, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=282, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=283, label="4_bit__AFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=284, label="4_bit__WFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=285, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=286, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=287, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=288, label="4_bit__AFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=289, label="4_bit__WFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=290, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=291, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=292, label="8_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" [id=293, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[2]", style=filled, type=__iadd__]; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=294, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" [color=green, id=295, label="8_bit__AFQ_#54", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=296, label=adaptive_avg_pool2d, scope="ResNet/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=297, label="4_bit__AFQ_#1", scope="ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=298, label="8_bit__WFQ_#1", scope="ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"299 ResNet/NNCFLinear[fc]/linear" [id=299, label=linear, scope="ResNet/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"3 ResNet/NNCFConv2d[conv1]/conv2d" -> "4 ResNet/BatchNorm2d[bn1]/batch_norm"; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" -> "5 ResNet/ReLU[relu]/RELU"; +"5 ResNet/ReLU[relu]/RELU" -> "6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" -> "27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" -> "44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" -> "61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" -> "82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" -> "99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" -> "116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" -> "133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" -> "154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" -> "171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" -> "188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" -> "205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm"; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" -> "210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" -> "214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm"; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" -> "215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" -> "219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm"; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" -> "220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" -> "222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" -> "226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm"; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" -> "227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" -> "231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm"; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" -> "232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" -> "236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm"; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" -> "237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" -> "239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" -> "260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" -> "277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" -> "294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize"; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" -> "296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__setup_type_propagation_based.dot new file mode 100644 index 00000000000..27919856bfa --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/resnet50_device_VPU__setup_type_propagation_based.dot @@ -0,0 +1,617 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=green, id=1, label="8_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 ResNet/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=3, label=conv2d, scope="ResNet/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" [id=4, label=batch_norm, scope="ResNet/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"5 ResNet/ReLU[relu]/RELU" [id=5, label=RELU, scope="ResNet/ReLU[relu]", style=filled, type=RELU]; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=6, label="4_bit__AFQ_#2", scope="ResNet/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" [id=7, label=max_pool2d, scope="ResNet/MaxPool2d[maxpool]", style=filled, type=max_pool2d]; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=8, label="8_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=9, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=10, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=11, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=12, label="4_bit__AFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=13, label="4_bit__WFQ_#4", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=14, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=15, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=16, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=17, label="8_bit__AFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=18, label="4_bit__WFQ_#5", scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=19, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=20, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=21, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=22, label="4_bit__WFQ_#2", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=23, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=24, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=25, label="8_bit__AFQ_#3", scope="ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" [id=26, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[0]", style=filled, type=__iadd__]; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" [id=27, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=28, label="4_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=29, label="4_bit__WFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=30, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=31, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=32, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=33, label="8_bit__AFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=34, label="8_bit__WFQ_#7", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=35, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=36, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=37, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=38, label="8_bit__AFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=39, label="8_bit__WFQ_#8", scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=40, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=41, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=42, label="8_bit__AFQ_#6", scope="ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" [id=43, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[1]", style=filled, type=__iadd__]; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" [id=44, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=45, label="4_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=46, label="8_bit__WFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=47, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=48, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=49, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=51, label="4_bit__WFQ_#10", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=52, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=53, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=54, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=55, label="8_bit__AFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=56, label="8_bit__WFQ_#11", scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=57, label=conv2d, scope="ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=58, label=batch_norm, scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=59, label="8_bit__AFQ_#9", scope="ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" [id=60, label=__iadd__, scope="ResNet/Sequential[layer1]/Bottleneck[2]", style=filled, type=__iadd__]; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" [id=61, label=RELU, scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=62, label="4_bit__AFQ_#12", scope="ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=63, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=64, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=65, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=66, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=67, label="8_bit__AFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=68, label="8_bit__WFQ_#14", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=69, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=70, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=71, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=72, label="4_bit__AFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=73, label="8_bit__WFQ_#15", scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=74, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=75, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=76, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=77, label="8_bit__WFQ_#12", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=78, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=79, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=80, label="4_bit__AFQ_#13", scope="ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" [id=81, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[0]", style=filled, type=__iadd__]; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" [id=82, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=84, label="8_bit__WFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=85, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=86, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=87, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=88, label="8_bit__AFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=89, label="8_bit__WFQ_#17", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=90, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=91, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=92, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=93, label="4_bit__AFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=94, label="2_bit__WFQ_#18", scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=95, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=96, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=97, label="8_bit__AFQ_#16", scope="ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" [id=98, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[1]", style=filled, type=__iadd__]; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" [id=99, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=100, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=101, label="8_bit__WFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=102, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=103, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=104, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=105, label="8_bit__AFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=106, label="8_bit__WFQ_#20", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=107, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=108, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=109, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=110, label="8_bit__AFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=111, label="2_bit__WFQ_#21", scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=112, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=113, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=114, label="4_bit__AFQ_#19", scope="ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" [id=115, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[2]", style=filled, type=__iadd__]; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" [id=116, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=117, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=118, label="4_bit__WFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=119, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=120, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=121, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=122, label="8_bit__AFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=123, label="2_bit__WFQ_#23", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=124, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=125, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=126, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=127, label="4_bit__AFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=128, label="2_bit__WFQ_#24", scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=129, label=conv2d, scope="ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=130, label=batch_norm, scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=131, label="8_bit__AFQ_#22", scope="ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" [id=132, label=__iadd__, scope="ResNet/Sequential[layer2]/Bottleneck[3]", style=filled, type=__iadd__]; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" [id=133, label=RELU, scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=134, label="4_bit__AFQ_#25", scope="ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=135, label="4_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=136, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=137, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=138, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=139, label="8_bit__AFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=140, label="8_bit__WFQ_#27", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=141, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=142, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=143, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=144, label="4_bit__AFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=145, label="4_bit__WFQ_#28", scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=146, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=147, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=148, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=149, label="8_bit__WFQ_#25", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=150, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=151, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=152, label="8_bit__AFQ_#26", scope="ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" [id=153, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[0]", style=filled, type=__iadd__]; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" [id=154, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=155, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=156, label="8_bit__WFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=157, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=158, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=159, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=160, label="8_bit__AFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=161, label="8_bit__WFQ_#30", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=162, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=163, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=164, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=165, label="8_bit__AFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=166, label="8_bit__WFQ_#31", scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=167, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=168, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=169, label="4_bit__AFQ_#29", scope="ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" [id=170, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[1]", style=filled, type=__iadd__]; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" [id=171, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=172, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=173, label="4_bit__WFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=174, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=175, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=176, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=177, label="4_bit__AFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=178, label="8_bit__WFQ_#33", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=179, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=180, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=181, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=182, label="8_bit__AFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=183, label="4_bit__WFQ_#34", scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=184, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=185, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=186, label="4_bit__AFQ_#32", scope="ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" [id=187, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[2]", style=filled, type=__iadd__]; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" [id=188, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=189, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=190, label="2_bit__WFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=191, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" [id=192, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=193, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=194, label="4_bit__AFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=195, label="4_bit__WFQ_#36", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=196, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" [id=197, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=198, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=199, label="8_bit__AFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=200, label="4_bit__WFQ_#37", scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=201, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" [id=202, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=203, label="4_bit__AFQ_#35", scope="ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" [id=204, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[3]", style=filled, type=__iadd__]; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" [id=205, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]", style=filled, type=RELU]; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=206, label="4_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=207, label="2_bit__WFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=208, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" [id=209, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=210, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=211, label="8_bit__AFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=212, label="4_bit__WFQ_#39", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=213, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" [id=214, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=215, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=216, label="8_bit__AFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=217, label="8_bit__WFQ_#40", scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=218, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" [id=219, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=220, label="8_bit__AFQ_#38", scope="ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" [id=221, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[4]", style=filled, type=__iadd__]; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" [id=222, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]", style=filled, type=RELU]; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=223, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=224, label="8_bit__WFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=225, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" [id=226, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=227, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=228, label="4_bit__AFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=229, label="2_bit__WFQ_#42", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=230, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" [id=231, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=232, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=233, label="8_bit__AFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=234, label="4_bit__WFQ_#43", scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=235, label=conv2d, scope="ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" [id=236, label=batch_norm, scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=237, label="4_bit__AFQ_#41", scope="ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" [id=238, label=__iadd__, scope="ResNet/Sequential[layer3]/Bottleneck[5]", style=filled, type=__iadd__]; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" [id=239, label=RELU, scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]", style=filled, type=RELU]; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=240, label="8_bit__AFQ_#44", scope="ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=241, label="8_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=242, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" [id=243, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=244, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=245, label="8_bit__AFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=246, label="8_bit__WFQ_#46", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=247, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" [id=248, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=249, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=250, label="4_bit__AFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=251, label="8_bit__WFQ_#47", scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=252, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" [id=253, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=254, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=255, label="4_bit__WFQ_#44", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" [color=lightblue, id=256, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]", style=filled, type=conv2d]; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" [id=257, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]", style=filled, type=batch_norm]; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=258, label="4_bit__AFQ_#45", scope="ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" [id=259, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[0]", style=filled, type=__iadd__]; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" [id=260, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]", style=filled, type=RELU]; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=261, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=262, label="2_bit__WFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=263, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" [id=264, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=265, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=266, label="8_bit__AFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=267, label="4_bit__WFQ_#49", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=268, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" [id=269, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=270, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=271, label="4_bit__AFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=272, label="2_bit__WFQ_#50", scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=273, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" [id=274, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=275, label="8_bit__AFQ_#48", scope="ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" [id=276, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[1]", style=filled, type=__iadd__]; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" [id=277, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]", style=filled, type=RELU]; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=278, label="4_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=279, label="2_bit__WFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" [color=lightblue, id=280, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]", style=filled, type=conv2d]; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" [id=281, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]", style=filled, type=batch_norm]; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=282, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=283, label="4_bit__AFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=284, label="2_bit__WFQ_#52", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" [color=lightblue, id=285, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]", style=filled, type=conv2d]; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" [id=286, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]", style=filled, type=batch_norm]; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=287, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=288, label="4_bit__AFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=289, label="2_bit__WFQ_#53", scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" [color=lightblue, id=290, label=conv2d, scope="ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]", style=filled, type=conv2d]; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" [id=291, label=batch_norm, scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]", style=filled, type=batch_norm]; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=292, label="8_bit__AFQ_#51", scope="ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" [id=293, label=__iadd__, scope="ResNet/Sequential[layer4]/Bottleneck[2]", style=filled, type=__iadd__]; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" [id=294, label=RELU, scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]", style=filled, type=RELU]; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" [color=green, id=295, label="8_bit__AFQ_#54", scope="ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" [id=296, label=adaptive_avg_pool2d, scope="ResNet/AdaptiveAvgPool2d[avgpool]", style=filled, type=adaptive_avg_pool2d]; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=297, label="4_bit__AFQ_#1", scope="ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=298, label="4_bit__WFQ_#1", scope="ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"299 ResNet/NNCFLinear[fc]/linear" [id=299, label=linear, scope="ResNet/NNCFLinear[fc]", style=filled, type=linear]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"2 ResNet/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 ResNet/NNCFConv2d[conv1]/conv2d"; +"3 ResNet/NNCFConv2d[conv1]/conv2d" -> "4 ResNet/BatchNorm2d[bn1]/batch_norm"; +"4 ResNet/BatchNorm2d[bn1]/batch_norm" -> "5 ResNet/ReLU[relu]/RELU"; +"5 ResNet/ReLU[relu]/RELU" -> "6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"6 ResNet/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "7 ResNet/MaxPool2d[maxpool]/max_pool2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"7 ResNet/MaxPool2d[maxpool]/max_pool2d" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"8 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"9 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"10 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"11 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"12 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"13 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"14 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"15 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"16 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"17 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"18 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"19 ResNet/Sequential[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"20 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"21 ResNet/Sequential[layer1]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"22 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"23 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"24 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"25 ResNet/Sequential[layer1]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__"; +"26 ResNet/Sequential[layer1]/Bottleneck[0]/__iadd__" -> "27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU"; +"27 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/RELU" -> "28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"28 ResNet/Sequential[layer1]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"29 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"30 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"31 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"32 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"33 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"34 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"35 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"36 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"37 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"38 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"39 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"40 ResNet/Sequential[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"41 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"42 ResNet/Sequential[layer1]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__"; +"43 ResNet/Sequential[layer1]/Bottleneck[1]/__iadd__" -> "44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU"; +"44 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/RELU" -> "45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"45 ResNet/Sequential[layer1]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"46 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"47 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"48 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"49 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"50 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"51 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"52 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"53 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"54 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"55 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"56 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"57 ResNet/Sequential[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"58 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"59 ResNet/Sequential[layer1]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__"; +"60 ResNet/Sequential[layer1]/Bottleneck[2]/__iadd__" -> "61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU"; +"61 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/RELU" -> "62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"62 ResNet/Sequential[layer1]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"63 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"64 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"65 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"66 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"67 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"68 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"69 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"70 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"71 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"72 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"73 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"74 ResNet/Sequential[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"75 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"76 ResNet/Sequential[layer2]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"77 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"78 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"79 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"80 ResNet/Sequential[layer2]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__"; +"81 ResNet/Sequential[layer2]/Bottleneck[0]/__iadd__" -> "82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU"; +"82 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/RELU" -> "83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"83 ResNet/Sequential[layer2]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"84 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"85 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"86 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"87 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"88 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"89 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"90 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"91 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"92 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"93 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"94 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"95 ResNet/Sequential[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"96 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"97 ResNet/Sequential[layer2]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__"; +"98 ResNet/Sequential[layer2]/Bottleneck[1]/__iadd__" -> "99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU"; +"99 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/RELU" -> "100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"100 ResNet/Sequential[layer2]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"101 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"102 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"103 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"104 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"105 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"106 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"107 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"108 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"109 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"110 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"111 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"112 ResNet/Sequential[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"113 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"114 ResNet/Sequential[layer2]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__"; +"115 ResNet/Sequential[layer2]/Bottleneck[2]/__iadd__" -> "116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU"; +"116 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/RELU" -> "117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"117 ResNet/Sequential[layer2]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"118 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"119 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"120 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"121 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"122 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"123 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"124 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"125 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"126 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"127 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"128 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"129 ResNet/Sequential[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"130 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"131 ResNet/Sequential[layer2]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__"; +"132 ResNet/Sequential[layer2]/Bottleneck[3]/__iadd__" -> "133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU"; +"133 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/RELU" -> "134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"134 ResNet/Sequential[layer2]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"135 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"136 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"137 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"138 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"139 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"140 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"141 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"142 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"143 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"144 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"145 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"146 ResNet/Sequential[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"147 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"148 ResNet/Sequential[layer3]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"149 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"150 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"151 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"152 ResNet/Sequential[layer3]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__"; +"153 ResNet/Sequential[layer3]/Bottleneck[0]/__iadd__" -> "154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU"; +"154 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/RELU" -> "155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"155 ResNet/Sequential[layer3]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"156 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"157 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"158 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"159 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"160 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"161 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"162 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"163 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"164 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"165 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"166 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"167 ResNet/Sequential[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"168 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"169 ResNet/Sequential[layer3]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__"; +"170 ResNet/Sequential[layer3]/Bottleneck[1]/__iadd__" -> "171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU"; +"171 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/RELU" -> "172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"172 ResNet/Sequential[layer3]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"173 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"174 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"175 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"176 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"177 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"178 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"179 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"180 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"181 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"182 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"183 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"184 ResNet/Sequential[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"185 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"186 ResNet/Sequential[layer3]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__"; +"187 ResNet/Sequential[layer3]/Bottleneck[2]/__iadd__" -> "188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU"; +"188 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/RELU" -> "189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"189 ResNet/Sequential[layer3]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"190 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d"; +"191 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d" -> "192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm"; +"192 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn1]/batch_norm" -> "193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"193 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"194 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"195 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d"; +"196 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d" -> "197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm"; +"197 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn2]/batch_norm" -> "198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"198 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"199 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"200 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d"; +"201 ResNet/Sequential[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d" -> "202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm"; +"202 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/batch_norm" -> "203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"203 ResNet/Sequential[layer3]/Bottleneck[3]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__"; +"204 ResNet/Sequential[layer3]/Bottleneck[3]/__iadd__" -> "205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU"; +"205 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/RELU" -> "206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"206 ResNet/Sequential[layer3]/Bottleneck[3]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"207 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d"; +"208 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d" -> "209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm"; +"209 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn1]/batch_norm" -> "210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"210 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"211 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"212 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d"; +"213 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d" -> "214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm"; +"214 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn2]/batch_norm" -> "215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"215 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"216 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"217 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d"; +"218 ResNet/Sequential[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d" -> "219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm"; +"219 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/batch_norm" -> "220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"220 ResNet/Sequential[layer3]/Bottleneck[4]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__"; +"221 ResNet/Sequential[layer3]/Bottleneck[4]/__iadd__" -> "222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU"; +"222 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/RELU" -> "223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"223 ResNet/Sequential[layer3]/Bottleneck[4]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"224 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d"; +"225 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d" -> "226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm"; +"226 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn1]/batch_norm" -> "227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"227 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"228 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"229 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d"; +"230 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d" -> "231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm"; +"231 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn2]/batch_norm" -> "232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"232 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"233 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"234 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d"; +"235 ResNet/Sequential[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d" -> "236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm"; +"236 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/batch_norm" -> "237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"237 ResNet/Sequential[layer3]/Bottleneck[5]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__"; +"238 ResNet/Sequential[layer3]/Bottleneck[5]/__iadd__" -> "239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU"; +"239 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/RELU" -> "240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"240 ResNet/Sequential[layer3]/Bottleneck[5]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"241 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d"; +"242 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d" -> "243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm"; +"243 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn1]/batch_norm" -> "244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"244 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"245 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"246 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d"; +"247 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d" -> "248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm"; +"248 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn2]/batch_norm" -> "249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"249 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"250 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"251 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d"; +"252 ResNet/Sequential[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d" -> "253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm"; +"253 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/batch_norm" -> "254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"254 ResNet/Sequential[layer4]/Bottleneck[0]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"255 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d"; +"256 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d" -> "257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm"; +"257 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/batch_norm" -> "258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize"; +"258 ResNet/Sequential[layer4]/Bottleneck[0]/Sequential[downsample]/BatchNorm2d[1]/AsymmetricQuantizer/asymmetric_quantize" -> "259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__"; +"259 ResNet/Sequential[layer4]/Bottleneck[0]/__iadd__" -> "260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU"; +"260 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/RELU" -> "261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"261 ResNet/Sequential[layer4]/Bottleneck[0]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"262 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d"; +"263 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d" -> "264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm"; +"264 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn1]/batch_norm" -> "265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"265 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"266 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"267 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d"; +"268 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d" -> "269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm"; +"269 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn2]/batch_norm" -> "270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"270 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"271 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"272 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d"; +"273 ResNet/Sequential[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d" -> "274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm"; +"274 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/batch_norm" -> "275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"275 ResNet/Sequential[layer4]/Bottleneck[1]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__"; +"276 ResNet/Sequential[layer4]/Bottleneck[1]/__iadd__" -> "277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU"; +"277 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/RELU" -> "278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"278 ResNet/Sequential[layer4]/Bottleneck[1]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"279 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d"; +"280 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d" -> "281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm"; +"281 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn1]/batch_norm" -> "282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"282 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"283 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"284 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d"; +"285 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d" -> "286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm"; +"286 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn2]/batch_norm" -> "287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"287 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize"; +"288 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/AsymmetricQuantizer/asymmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"289 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d"; +"290 ResNet/Sequential[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d" -> "291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm"; +"291 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/batch_norm" -> "292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize"; +"292 ResNet/Sequential[layer4]/Bottleneck[2]/BatchNorm2d[bn3]/AsymmetricQuantizer/asymmetric_quantize" -> "293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__"; +"293 ResNet/Sequential[layer4]/Bottleneck[2]/__iadd__" -> "294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU"; +"294 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/RELU" -> "295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize"; +"295 ResNet/Sequential[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize" -> "296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d"; +"296 ResNet/AdaptiveAvgPool2d[avgpool]/adaptive_avg_pool2d" -> "297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize"; +"297 ResNet/AdaptiveAvgPool2d[avgpool]/AsymmetricQuantizer/asymmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +"298 ResNet/NNCFLinear[fc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "299 ResNet/NNCFLinear[fc]/linear"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/squeezenet1_1_device_VPU__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/squeezenet1_1_device_VPU__setup_type_propagation_based.dot new file mode 100644 index 00000000000..24157d6fab7 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/squeezenet1_1_device_VPU__setup_type_propagation_based.dot @@ -0,0 +1,247 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 SqueezeNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=2, label="4_bit__WFQ_#0", scope="SqueezeNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="SqueezeNet/Sequential[features]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 SqueezeNet/Sequential[features]/ReLU[1]/RELU" [id=4, label=RELU, scope="SqueezeNet/Sequential[features]/ReLU[1]", style=filled, type=RELU]; +"5 SqueezeNet/Sequential[features]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=5, label="8_bit__AFQ_#18", scope="SqueezeNet/Sequential[features]/ReLU[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"6 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d" [id=6, label=max_pool2d, scope="SqueezeNet/Sequential[features]/MaxPool2d[2]", style=filled, type=max_pool2d]; +"7 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=7, label="4_bit__WFQ_#18", scope="SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=8, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"9 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/RELU" [id=9, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=10, label="4_bit__AFQ_#9", scope="SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"11 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=11, label="4_bit__WFQ_#9", scope="SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=12, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/RELU" [id=13, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=14, label="4_bit__AFQ_#8", scope="SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"15 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=15, label="4_bit__WFQ_#9", scope="SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=16, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"17 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/RELU" [id=17, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"18 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=18, label="8_bit__AFQ_#8", scope="SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"19 SqueezeNet/Sequential[features]/Fire[3]/cat" [id=19, label=cat, scope="SqueezeNet/Sequential[features]/Fire[3]", style=filled, type=cat]; +"20 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=20, label="4_bit__WFQ_#8", scope="SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=21, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"22 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/RELU" [id=22, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=23, label="4_bit__AFQ_#11", scope="SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"24 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=24, label="4_bit__WFQ_#11", scope="SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=25, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"26 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/RELU" [id=26, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"27 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=27, label="8_bit__AFQ_#10", scope="SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"28 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=28, label="2_bit__WFQ_#11", scope="SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=29, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"30 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/RELU" [id=30, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"31 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=31, label="8_bit__AFQ_#10", scope="SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"32 SqueezeNet/Sequential[features]/Fire[4]/cat" [id=32, label=cat, scope="SqueezeNet/Sequential[features]/Fire[4]", style=filled, type=cat]; +"33 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d" [id=33, label=max_pool2d, scope="SqueezeNet/Sequential[features]/MaxPool2d[5]", style=filled, type=max_pool2d]; +"34 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=34, label="2_bit__WFQ_#10", scope="SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=35, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"36 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/RELU" [id=36, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=37, label="8_bit__AFQ_#13", scope="SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"38 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=38, label="4_bit__WFQ_#13", scope="SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=39, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"40 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/RELU" [id=40, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"41 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=41, label="8_bit__AFQ_#12", scope="SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"42 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=42, label="8_bit__WFQ_#13", scope="SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=43, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"44 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/RELU" [id=44, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"45 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=45, label="8_bit__AFQ_#12", scope="SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"46 SqueezeNet/Sequential[features]/Fire[6]/cat" [id=46, label=cat, scope="SqueezeNet/Sequential[features]/Fire[6]", style=filled, type=cat]; +"47 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=47, label="2_bit__WFQ_#12", scope="SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=48, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"49 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/RELU" [id=49, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#15", scope="SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=51, label="4_bit__WFQ_#15", scope="SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=52, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"53 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/RELU" [id=53, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"54 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=54, label="4_bit__AFQ_#14", scope="SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"55 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=55, label="4_bit__WFQ_#15", scope="SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=56, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"57 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/RELU" [id=57, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"58 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=58, label="4_bit__AFQ_#14", scope="SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"59 SqueezeNet/Sequential[features]/Fire[7]/cat" [id=59, label=cat, scope="SqueezeNet/Sequential[features]/Fire[7]", style=filled, type=cat]; +"60 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d" [id=60, label=max_pool2d, scope="SqueezeNet/Sequential[features]/MaxPool2d[8]", style=filled, type=max_pool2d]; +"61 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=61, label="4_bit__WFQ_#14", scope="SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=62, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"63 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/RELU" [id=63, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=64, label="4_bit__AFQ_#17", scope="SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"65 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=65, label="8_bit__WFQ_#17", scope="SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=66, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"67 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/RELU" [id=67, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"68 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=68, label="8_bit__AFQ_#16", scope="SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"69 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=69, label="4_bit__WFQ_#17", scope="SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=70, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"71 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/RELU" [id=71, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"72 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=72, label="8_bit__AFQ_#16", scope="SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"73 SqueezeNet/Sequential[features]/Fire[9]/cat" [id=73, label=cat, scope="SqueezeNet/Sequential[features]/Fire[9]", style=filled, type=cat]; +"74 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=74, label="2_bit__WFQ_#16", scope="SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=75, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"76 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/RELU" [id=76, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=77, label="8_bit__AFQ_#3", scope="SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"78 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=78, label="8_bit__WFQ_#3", scope="SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=79, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"80 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/RELU" [id=80, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"81 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=81, label="4_bit__AFQ_#2", scope="SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"82 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=82, label="8_bit__WFQ_#3", scope="SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=83, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"84 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/RELU" [id=84, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"85 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=85, label="4_bit__AFQ_#2", scope="SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"86 SqueezeNet/Sequential[features]/Fire[10]/cat" [id=86, label=cat, scope="SqueezeNet/Sequential[features]/Fire[10]", style=filled, type=cat]; +"87 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=87, label="8_bit__WFQ_#2", scope="SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=88, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"89 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/RELU" [id=89, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=90, label="4_bit__AFQ_#5", scope="SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"91 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=91, label="4_bit__WFQ_#5", scope="SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=92, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"93 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/RELU" [id=93, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"94 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=94, label="8_bit__AFQ_#4", scope="SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"95 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=95, label="2_bit__WFQ_#5", scope="SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=96, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"97 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/RELU" [id=97, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"98 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=98, label="8_bit__AFQ_#4", scope="SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"99 SqueezeNet/Sequential[features]/Fire[11]/cat" [id=99, label=cat, scope="SqueezeNet/Sequential[features]/Fire[11]", style=filled, type=cat]; +"100 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=100, label="2_bit__WFQ_#4", scope="SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d" [color=lightblue, id=101, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]", style=filled, type=conv2d]; +"102 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/RELU" [id=102, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]", style=filled, type=RELU]; +"103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=103, label="8_bit__AFQ_#7", scope="SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"104 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=104, label="4_bit__WFQ_#7", scope="SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d" [color=lightblue, id=105, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]", style=filled, type=conv2d]; +"106 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/RELU" [id=106, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]", style=filled, type=RELU]; +"107 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=107, label="8_bit__AFQ_#6", scope="SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"108 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=108, label="8_bit__WFQ_#7", scope="SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d" [color=lightblue, id=109, label=conv2d, scope="SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]", style=filled, type=conv2d]; +"110 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/RELU" [id=110, label=RELU, scope="SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]", style=filled, type=RELU]; +"111 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=111, label="4_bit__AFQ_#6", scope="SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"112 SqueezeNet/Sequential[features]/Fire[12]/cat" [id=112, label=cat, scope="SqueezeNet/Sequential[features]/Fire[12]", style=filled, type=cat]; +"113 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout" [id=113, label=dropout, scope="SqueezeNet/Sequential[classifier]/Dropout[0]", style=filled, type=dropout]; +"114 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=114, label="4_bit__WFQ_#6", scope="SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d" [color=lightblue, id=115, label=conv2d, scope="SqueezeNet/Sequential[classifier]/NNCFConv2d[1]", style=filled, type=conv2d]; +"116 SqueezeNet/Sequential[classifier]/ReLU[2]/RELU" [id=116, label=RELU, scope="SqueezeNet/Sequential[classifier]/ReLU[2]", style=filled, type=RELU]; +"117 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize" [color=green, id=117, label="8_bit__AFQ_#1", scope="SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer", style=filled, type=symmetric_quantize]; +"118 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d" [id=118, label=adaptive_avg_pool2d, scope="SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]", style=filled, type=adaptive_avg_pool2d]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d"; +"2 SqueezeNet/Sequential[features]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d"; +"3 SqueezeNet/Sequential[features]/NNCFConv2d[0]/conv2d" -> "4 SqueezeNet/Sequential[features]/ReLU[1]/RELU"; +"4 SqueezeNet/Sequential[features]/ReLU[1]/RELU" -> "5 SqueezeNet/Sequential[features]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize"; +"5 SqueezeNet/Sequential[features]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" -> "6 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d"; +"6 SqueezeNet/Sequential[features]/MaxPool2d[2]/max_pool2d" -> "8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d"; +"7 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d"; +"8 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[squeeze]/conv2d" -> "9 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/RELU"; +"9 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/RELU" -> "10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d"; +"10 SqueezeNet/Sequential[features]/Fire[3]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d"; +"11 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d"; +"12 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand1x1]/conv2d" -> "13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/RELU"; +"13 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/RELU" -> "14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"14 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "19 SqueezeNet/Sequential[features]/Fire[3]/cat"; +"15 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d"; +"16 SqueezeNet/Sequential[features]/Fire[3]/NNCFConv2d[expand3x3]/conv2d" -> "17 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/RELU"; +"17 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/RELU" -> "18 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"18 SqueezeNet/Sequential[features]/Fire[3]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "19 SqueezeNet/Sequential[features]/Fire[3]/cat"; +"19 SqueezeNet/Sequential[features]/Fire[3]/cat" -> "21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d"; +"20 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d"; +"21 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[squeeze]/conv2d" -> "22 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/RELU"; +"22 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/RELU" -> "23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d"; +"23 SqueezeNet/Sequential[features]/Fire[4]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d"; +"24 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d"; +"25 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand1x1]/conv2d" -> "26 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/RELU"; +"26 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/RELU" -> "27 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"27 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "32 SqueezeNet/Sequential[features]/Fire[4]/cat"; +"28 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d"; +"29 SqueezeNet/Sequential[features]/Fire[4]/NNCFConv2d[expand3x3]/conv2d" -> "30 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/RELU"; +"30 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/RELU" -> "31 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"31 SqueezeNet/Sequential[features]/Fire[4]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "32 SqueezeNet/Sequential[features]/Fire[4]/cat"; +"32 SqueezeNet/Sequential[features]/Fire[4]/cat" -> "33 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d"; +"33 SqueezeNet/Sequential[features]/MaxPool2d[5]/max_pool2d" -> "35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d"; +"34 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d"; +"35 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[squeeze]/conv2d" -> "36 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/RELU"; +"36 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/RELU" -> "37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d"; +"37 SqueezeNet/Sequential[features]/Fire[6]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d"; +"38 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d"; +"39 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand1x1]/conv2d" -> "40 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/RELU"; +"40 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/RELU" -> "41 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"41 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "46 SqueezeNet/Sequential[features]/Fire[6]/cat"; +"42 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d"; +"43 SqueezeNet/Sequential[features]/Fire[6]/NNCFConv2d[expand3x3]/conv2d" -> "44 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/RELU"; +"44 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/RELU" -> "45 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"45 SqueezeNet/Sequential[features]/Fire[6]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "46 SqueezeNet/Sequential[features]/Fire[6]/cat"; +"46 SqueezeNet/Sequential[features]/Fire[6]/cat" -> "48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d"; +"47 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d"; +"48 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[squeeze]/conv2d" -> "49 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/RELU"; +"49 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/RELU" -> "50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d"; +"50 SqueezeNet/Sequential[features]/Fire[7]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d"; +"51 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d"; +"52 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand1x1]/conv2d" -> "53 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/RELU"; +"53 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/RELU" -> "54 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"54 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "59 SqueezeNet/Sequential[features]/Fire[7]/cat"; +"55 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d"; +"56 SqueezeNet/Sequential[features]/Fire[7]/NNCFConv2d[expand3x3]/conv2d" -> "57 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/RELU"; +"57 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/RELU" -> "58 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"58 SqueezeNet/Sequential[features]/Fire[7]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "59 SqueezeNet/Sequential[features]/Fire[7]/cat"; +"59 SqueezeNet/Sequential[features]/Fire[7]/cat" -> "60 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d"; +"60 SqueezeNet/Sequential[features]/MaxPool2d[8]/max_pool2d" -> "62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d"; +"61 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d"; +"62 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[squeeze]/conv2d" -> "63 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/RELU"; +"63 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/RELU" -> "64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d"; +"64 SqueezeNet/Sequential[features]/Fire[9]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d"; +"65 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d"; +"66 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand1x1]/conv2d" -> "67 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/RELU"; +"67 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/RELU" -> "68 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"68 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "73 SqueezeNet/Sequential[features]/Fire[9]/cat"; +"69 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d"; +"70 SqueezeNet/Sequential[features]/Fire[9]/NNCFConv2d[expand3x3]/conv2d" -> "71 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/RELU"; +"71 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/RELU" -> "72 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"72 SqueezeNet/Sequential[features]/Fire[9]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "73 SqueezeNet/Sequential[features]/Fire[9]/cat"; +"73 SqueezeNet/Sequential[features]/Fire[9]/cat" -> "75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d"; +"74 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d"; +"75 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[squeeze]/conv2d" -> "76 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/RELU"; +"76 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/RELU" -> "77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d"; +"77 SqueezeNet/Sequential[features]/Fire[10]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d"; +"78 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d"; +"79 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand1x1]/conv2d" -> "80 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/RELU"; +"80 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/RELU" -> "81 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"81 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "86 SqueezeNet/Sequential[features]/Fire[10]/cat"; +"82 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d"; +"83 SqueezeNet/Sequential[features]/Fire[10]/NNCFConv2d[expand3x3]/conv2d" -> "84 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/RELU"; +"84 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/RELU" -> "85 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"85 SqueezeNet/Sequential[features]/Fire[10]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "86 SqueezeNet/Sequential[features]/Fire[10]/cat"; +"86 SqueezeNet/Sequential[features]/Fire[10]/cat" -> "88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d"; +"87 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d"; +"88 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[squeeze]/conv2d" -> "89 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/RELU"; +"89 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/RELU" -> "90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d"; +"90 SqueezeNet/Sequential[features]/Fire[11]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d"; +"91 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d"; +"92 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand1x1]/conv2d" -> "93 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/RELU"; +"93 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/RELU" -> "94 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"94 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "99 SqueezeNet/Sequential[features]/Fire[11]/cat"; +"95 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d"; +"96 SqueezeNet/Sequential[features]/Fire[11]/NNCFConv2d[expand3x3]/conv2d" -> "97 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/RELU"; +"97 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/RELU" -> "98 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"98 SqueezeNet/Sequential[features]/Fire[11]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "99 SqueezeNet/Sequential[features]/Fire[11]/cat"; +"99 SqueezeNet/Sequential[features]/Fire[11]/cat" -> "101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d"; +"100 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d"; +"101 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[squeeze]/conv2d" -> "102 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/RELU"; +"102 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/RELU" -> "103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d"; +"103 SqueezeNet/Sequential[features]/Fire[12]/ReLU[squeeze_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d"; +"104 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d"; +"105 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand1x1]/conv2d" -> "106 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/RELU"; +"106 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/RELU" -> "107 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"107 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand1x1_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "112 SqueezeNet/Sequential[features]/Fire[12]/cat"; +"108 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d"; +"109 SqueezeNet/Sequential[features]/Fire[12]/NNCFConv2d[expand3x3]/conv2d" -> "110 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/RELU"; +"110 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/RELU" -> "111 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize"; +"111 SqueezeNet/Sequential[features]/Fire[12]/ReLU[expand3x3_activation]/AsymmetricQuantizer/asymmetric_quantize" -> "112 SqueezeNet/Sequential[features]/Fire[12]/cat"; +"112 SqueezeNet/Sequential[features]/Fire[12]/cat" -> "113 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout"; +"113 SqueezeNet/Sequential[classifier]/Dropout[0]/dropout" -> "115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d"; +"114 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d"; +"115 SqueezeNet/Sequential[classifier]/NNCFConv2d[1]/conv2d" -> "116 SqueezeNet/Sequential[classifier]/ReLU[2]/RELU"; +"116 SqueezeNet/Sequential[classifier]/ReLU[2]/RELU" -> "117 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize"; +"117 SqueezeNet/Sequential[classifier]/ReLU[2]/SymmetricQuantizer/symmetric_quantize" -> "118 SqueezeNet/Sequential[classifier]/AdaptiveAvgPool2d[3]/adaptive_avg_pool2d"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/ssd_vgg_512_test_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/ssd_vgg_512_test_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..47157399894 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/ssd_vgg_512_test_device_VPU__eval_subset_ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,299 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/RELU" [id=4, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]", style=filled, type=RELU]; +"5 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=5, label="4_bit__AFQ_#8", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=6, label="8_bit__WFQ_#8", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d" [color=lightblue, id=7, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]", style=filled, type=conv2d]; +"8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/RELU" [id=8, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]", style=filled, type=RELU]; +"9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=9, label="8_bit__AFQ_#16", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"10 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]/max_pool2d" [id=10, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]", style=filled, type=max_pool2d]; +"11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=11, label="8_bit__WFQ_#16", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d" [color=lightblue, id=12, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]", style=filled, type=conv2d]; +"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/RELU" [id=13, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]", style=filled, type=RELU]; +"14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=14, label="4_bit__AFQ_#17", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"15 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=15, label="4_bit__WFQ_#17", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d" [color=lightblue, id=16, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]", style=filled, type=conv2d]; +"17 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/RELU" [id=17, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]", style=filled, type=RELU]; +"18 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=18, label="4_bit__AFQ_#18", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"19 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]/max_pool2d" [id=19, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]", style=filled, type=max_pool2d]; +"20 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=20, label="4_bit__WFQ_#18", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d" [color=lightblue, id=21, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]", style=filled, type=conv2d]; +"22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/RELU" [id=22, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]", style=filled, type=RELU]; +"23 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=23, label="4_bit__AFQ_#4", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"24 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=24, label="4_bit__WFQ_#4", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d" [color=lightblue, id=25, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]", style=filled, type=conv2d]; +"26 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/RELU" [id=26, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]", style=filled, type=RELU]; +"27 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=27, label="4_bit__AFQ_#5", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=28, label="2_bit__WFQ_#5", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d" [color=lightblue, id=29, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]", style=filled, type=conv2d]; +"30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/RELU" [id=30, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]", style=filled, type=RELU]; +"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=31, label="8_bit__AFQ_#6", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"32 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]/max_pool2d" [id=32, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]", style=filled, type=max_pool2d]; +"33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=33, label="8_bit__WFQ_#6", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d" [color=lightblue, id=34, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]", style=filled, type=conv2d]; +"35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/RELU" [id=35, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]", style=filled, type=RELU]; +"36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=36, label="4_bit__AFQ_#7", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"37 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=37, label="8_bit__WFQ_#7", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d" [color=lightblue, id=38, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]", style=filled, type=conv2d]; +"39 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/RELU" [id=39, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]", style=filled, type=RELU]; +"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=40, label="4_bit__AFQ_#9", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"41 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=41, label="8_bit__WFQ_#9", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d" [color=lightblue, id=42, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]", style=filled, type=conv2d]; +"43 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/RELU" [id=43, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]", style=filled, type=RELU]; +"44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=44, label="8_bit__AFQ_#10", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"45 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d" [id=45, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]", style=filled, type=max_pool2d]; +"46 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=46, label="4_bit__AFQ_#3", scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"47 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=47, label="8_bit__WFQ_#3", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d" [color=lightblue, id=48, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]", style=filled, type=conv2d]; +"49 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/RELU" [id=49, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]", style=filled, type=RELU]; +"50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#11", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#11", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d" [color=lightblue, id=52, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]", style=filled, type=conv2d]; +"53 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/RELU" [id=53, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]", style=filled, type=RELU]; +"54 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=54, label="4_bit__AFQ_#12", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"55 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=55, label="2_bit__WFQ_#12", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d" [color=lightblue, id=56, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]", style=filled, type=conv2d]; +"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/RELU" [id=57, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]", style=filled, type=RELU]; +"58 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=58, label="8_bit__AFQ_#13", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"59 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]/max_pool2d" [id=59, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]", style=filled, type=max_pool2d]; +"60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=60, label="2_bit__WFQ_#13", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d" [color=lightblue, id=61, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]", style=filled, type=conv2d]; +"62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/RELU" [id=62, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]", style=filled, type=RELU]; +"63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=63, label="8_bit__AFQ_#14", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"64 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=64, label="2_bit__WFQ_#14", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d" [color=lightblue, id=65, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]", style=filled, type=conv2d]; +"66 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/RELU" [id=66, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]", style=filled, type=RELU]; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=67, label="8_bit__AFQ_#15", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 SSD_VGG/L2Norm[L2Norm]/div" [id=68, label=div, scope="SSD_VGG/L2Norm[L2Norm]", style=filled, type=div]; +"69 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=69, label="8_bit__AFQ_#2", scope="SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"70 SSD_VGG/L2Norm[L2Norm]/__rmul__" [id=70, label=__rmul__, scope="SSD_VGG/L2Norm[L2Norm]", style=filled, type=__rmul__]; +"71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=71, label="4_bit__AFQ_#1", scope="SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"72 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=72, label="4_bit__WFQ_#15", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d" [color=lightblue, id=73, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]", style=filled, type=conv2d]; +"74 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/RELU" [id=74, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[1]", style=filled, type=RELU]; +"75 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=75, label="4_bit__AFQ_#24", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=76, label="4_bit__WFQ_#24", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d" [color=lightblue, id=77, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]", style=filled, type=conv2d]; +"78 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/RELU" [id=78, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[3]", style=filled, type=RELU]; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=79, label="8_bit__AFQ_#25", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"80 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=80, label="4_bit__WFQ_#25", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d" [color=lightblue, id=81, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]", style=filled, type=conv2d]; +"82 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/RELU" [id=82, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[5]", style=filled, type=RELU]; +"83 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#26", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=84, label="4_bit__WFQ_#26", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d" [color=lightblue, id=85, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]", style=filled, type=conv2d]; +"86 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/RELU" [id=86, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[7]", style=filled, type=RELU]; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=87, label="4_bit__AFQ_#27", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"88 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=88, label="4_bit__WFQ_#27", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d" [color=lightblue, id=89, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]", style=filled, type=conv2d]; +"90 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/RELU" [id=90, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[9]", style=filled, type=RELU]; +"91 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=91, label="8_bit__AFQ_#28", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=92, label="2_bit__WFQ_#28", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d" [color=lightblue, id=93, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]", style=filled, type=conv2d]; +"94 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/RELU" [id=94, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[11]", style=filled, type=RELU]; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=95, label="8_bit__AFQ_#19", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"96 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=96, label="2_bit__WFQ_#19", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d" [color=lightblue, id=97, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]", style=filled, type=conv2d]; +"98 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/RELU" [id=98, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[13]", style=filled, type=RELU]; +"99 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=99, label="8_bit__AFQ_#20", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"100 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=100, label="4_bit__WFQ_#20", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d" [color=lightblue, id=101, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]", style=filled, type=conv2d]; +"102 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/RELU" [id=102, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[15]", style=filled, type=RELU]; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=103, label="8_bit__AFQ_#21", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"104 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=104, label="4_bit__WFQ_#21", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d" [color=lightblue, id=105, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]", style=filled, type=conv2d]; +"106 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/RELU" [id=106, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[17]", style=filled, type=RELU]; +"107 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=107, label="8_bit__AFQ_#22", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=108, label="2_bit__WFQ_#22", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d" [color=lightblue, id=109, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]", style=filled, type=conv2d]; +"110 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/RELU" [id=110, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[19]", style=filled, type=RELU]; +"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=111, label="8_bit__AFQ_#23", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"112 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=112, label="4_bit__WFQ_#1", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=113, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"114 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=114, label="2_bit__WFQ_#1", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=115, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"116 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=116, label="4_bit__WFQ_#15", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=117, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"118 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=118, label="2_bit__WFQ_#15", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=119, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"120 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=120, label="2_bit__WFQ_#25", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=121, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"122 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=122, label="4_bit__WFQ_#25", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=123, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"124 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=124, label="2_bit__WFQ_#27", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=125, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"126 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=126, label="4_bit__WFQ_#27", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=127, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"128 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=128, label="2_bit__WFQ_#19", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=129, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"130 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=130, label="2_bit__WFQ_#19", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=131, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"132 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=132, label="2_bit__WFQ_#21", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=133, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"134 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=134, label="4_bit__WFQ_#21", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=135, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=136, label="4_bit__WFQ_#23", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=137, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=138, label="4_bit__WFQ_#23", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=139, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"140 SSD_VGG/SSDDetectionOutput[detection_head]/cat" [id=140, label=cat, scope="SSD_VGG/SSDDetectionOutput[detection_head]", style=filled, type=cat]; +"141 SSD_VGG/SSDDetectionOutput[detection_head]/cat" [id=141, label=cat, scope="SSD_VGG/SSDDetectionOutput[detection_head]", style=filled, type=cat]; +"142 SSD_VGG/SSDDetectionOutput[detection_head]/softmax" [id=142, label=softmax, scope="SSD_VGG/SSDDetectionOutput[detection_head]", style=filled, type=softmax]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d"; +"2 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d"; +"3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d" -> "4 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/RELU"; +"4 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/RELU" -> "5 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize"; +"5 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" -> "7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d"; +"6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d"; +"7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d" -> "8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/RELU"; +"8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/RELU" -> "9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize"; +"9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "10 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]/max_pool2d"; +"10 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]/max_pool2d" -> "12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d"; +"11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d"; +"12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d" -> "13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/RELU"; +"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/RELU" -> "14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer/asymmetric_quantize"; +"14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer/asymmetric_quantize" -> "16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d"; +"15 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d"; +"16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d" -> "17 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/RELU"; +"17 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/RELU" -> "18 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer/asymmetric_quantize"; +"18 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer/asymmetric_quantize" -> "19 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]/max_pool2d"; +"19 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]/max_pool2d" -> "21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d"; +"20 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d"; +"21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d" -> "22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/RELU"; +"22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/RELU" -> "23 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize"; +"23 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d"; +"24 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d"; +"25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d" -> "26 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/RELU"; +"26 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/RELU" -> "27 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize"; +"27 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" -> "29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d"; +"28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d"; +"29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d" -> "30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/RELU"; +"30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/RELU" -> "31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize"; +"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "32 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]/max_pool2d"; +"32 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]/max_pool2d" -> "34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d"; +"33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d"; +"34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d" -> "35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/RELU"; +"35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/RELU" -> "36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer/asymmetric_quantize"; +"36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer/asymmetric_quantize" -> "38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d"; +"37 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d"; +"38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d" -> "39 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/RELU"; +"39 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/RELU" -> "40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer/asymmetric_quantize"; +"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer/asymmetric_quantize" -> "42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d"; +"41 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d"; +"42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d" -> "43 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/RELU"; +"43 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/RELU" -> "44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize"; +"44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize" -> "45 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d"; +"44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize" -> "68 SSD_VGG/L2Norm[L2Norm]/div"; +"45 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d" -> "46 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer/asymmetric_quantize"; +"46 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer/asymmetric_quantize" -> "48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d"; +"47 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d"; +"48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d" -> "49 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/RELU"; +"49 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/RELU" -> "50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer/asymmetric_quantize"; +"50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer/asymmetric_quantize" -> "52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d"; +"51 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d"; +"52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d" -> "53 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/RELU"; +"53 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/RELU" -> "54 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer/asymmetric_quantize"; +"54 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer/asymmetric_quantize" -> "56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d"; +"55 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d"; +"56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d" -> "57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/RELU"; +"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/RELU" -> "58 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer/asymmetric_quantize"; +"58 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer/asymmetric_quantize" -> "59 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]/max_pool2d"; +"59 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]/max_pool2d" -> "61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d"; +"60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d"; +"61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d" -> "62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/RELU"; +"62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/RELU" -> "63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer/asymmetric_quantize"; +"63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer/asymmetric_quantize" -> "65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d"; +"64 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d"; +"65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d" -> "66 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/RELU"; +"66 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/RELU" -> "67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize"; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" -> "73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d"; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" -> "117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d"; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" -> "119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d"; +"68 SSD_VGG/L2Norm[L2Norm]/div" -> "69 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize"; +"69 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" -> "70 SSD_VGG/L2Norm[L2Norm]/__rmul__"; +"70 SSD_VGG/L2Norm[L2Norm]/__rmul__" -> "71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize"; +"71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" -> "113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d"; +"71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" -> "115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d"; +"72 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d"; +"73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d" -> "74 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/RELU"; +"74 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/RELU" -> "75 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize"; +"75 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" -> "77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d"; +"76 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d"; +"77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d" -> "78 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/RELU"; +"78 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/RELU" -> "79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize"; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d"; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d"; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d"; +"80 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d"; +"81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d" -> "82 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/RELU"; +"82 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/RELU" -> "83 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer/asymmetric_quantize"; +"83 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer/asymmetric_quantize" -> "85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d"; +"84 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d"; +"85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d" -> "86 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/RELU"; +"86 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/RELU" -> "87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize"; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" -> "89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d"; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" -> "125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d"; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" -> "127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d"; +"88 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d"; +"89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d" -> "90 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/RELU"; +"90 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/RELU" -> "91 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer/asymmetric_quantize"; +"91 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer/asymmetric_quantize" -> "93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d"; +"92 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d"; +"93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d" -> "94 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/RELU"; +"94 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/RELU" -> "95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize"; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d"; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d"; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d"; +"96 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d"; +"97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d" -> "98 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/RELU"; +"98 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/RELU" -> "99 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize"; +"99 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" -> "101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d"; +"100 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d"; +"101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d" -> "102 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/RELU"; +"102 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/RELU" -> "103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize"; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d"; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d"; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d"; +"104 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d"; +"105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d" -> "106 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/RELU"; +"106 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/RELU" -> "107 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer/asymmetric_quantize"; +"107 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer/asymmetric_quantize" -> "109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d"; +"108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d"; +"109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d" -> "110 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/RELU"; +"110 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/RELU" -> "111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize"; +"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize" -> "137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d"; +"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize" -> "139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d"; +"112 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d"; +"113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"114 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d"; +"115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"116 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d"; +"117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"118 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d"; +"119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"120 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d"; +"121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"122 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d"; +"123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"124 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d"; +"125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"126 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d"; +"127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"128 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d"; +"129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"130 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d"; +"131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"132 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d"; +"133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"134 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d"; +"135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d"; +"137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d"; +"139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"141 SSD_VGG/SSDDetectionOutput[detection_head]/cat" -> "142 SSD_VGG/SSDDetectionOutput[detection_head]/softmax"; +} diff --git a/tests/data/reference_graphs/quantized/autoq/ssd_vgg_512_test_device_VPU__ratio_0.4__setup_type_propagation_based.dot b/tests/data/reference_graphs/quantized/autoq/ssd_vgg_512_test_device_VPU__ratio_0.4__setup_type_propagation_based.dot new file mode 100644 index 00000000000..0dafb323c45 --- /dev/null +++ b/tests/data/reference_graphs/quantized/autoq/ssd_vgg_512_test_device_VPU__ratio_0.4__setup_type_propagation_based.dot @@ -0,0 +1,299 @@ +strict digraph { +"0 /nncf_model_input" [id=0, label=nncf_model_input, scope="", style=filled, type=nncf_model_input]; +"1 AsymmetricQuantizer/asymmetric_quantize" [color=red, id=1, label="4_bit__AFQ_#0", scope=AsymmetricQuantizer, style=filled, type=asymmetric_quantize]; +"2 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=2, label="8_bit__WFQ_#0", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d" [color=lightblue, id=3, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]", style=filled, type=conv2d]; +"4 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/RELU" [id=4, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]", style=filled, type=RELU]; +"5 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=5, label="4_bit__AFQ_#8", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=6, label="8_bit__WFQ_#8", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d" [color=lightblue, id=7, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]", style=filled, type=conv2d]; +"8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/RELU" [id=8, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]", style=filled, type=RELU]; +"9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=9, label="8_bit__AFQ_#16", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"10 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]/max_pool2d" [id=10, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]", style=filled, type=max_pool2d]; +"11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=11, label="8_bit__WFQ_#16", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d" [color=lightblue, id=12, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]", style=filled, type=conv2d]; +"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/RELU" [id=13, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]", style=filled, type=RELU]; +"14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=14, label="4_bit__AFQ_#17", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"15 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=15, label="4_bit__WFQ_#17", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d" [color=lightblue, id=16, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]", style=filled, type=conv2d]; +"17 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/RELU" [id=17, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]", style=filled, type=RELU]; +"18 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=18, label="4_bit__AFQ_#18", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"19 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]/max_pool2d" [id=19, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]", style=filled, type=max_pool2d]; +"20 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=20, label="4_bit__WFQ_#18", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d" [color=lightblue, id=21, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]", style=filled, type=conv2d]; +"22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/RELU" [id=22, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]", style=filled, type=RELU]; +"23 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=23, label="4_bit__AFQ_#4", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"24 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=24, label="4_bit__WFQ_#4", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d" [color=lightblue, id=25, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]", style=filled, type=conv2d]; +"26 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/RELU" [id=26, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]", style=filled, type=RELU]; +"27 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=27, label="4_bit__AFQ_#5", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=28, label="2_bit__WFQ_#5", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d" [color=lightblue, id=29, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]", style=filled, type=conv2d]; +"30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/RELU" [id=30, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]", style=filled, type=RELU]; +"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=31, label="8_bit__AFQ_#6", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"32 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]/max_pool2d" [id=32, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]", style=filled, type=max_pool2d]; +"33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=33, label="8_bit__WFQ_#6", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d" [color=lightblue, id=34, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]", style=filled, type=conv2d]; +"35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/RELU" [id=35, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]", style=filled, type=RELU]; +"36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=36, label="4_bit__AFQ_#7", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"37 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=37, label="8_bit__WFQ_#7", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d" [color=lightblue, id=38, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]", style=filled, type=conv2d]; +"39 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/RELU" [id=39, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]", style=filled, type=RELU]; +"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=40, label="4_bit__AFQ_#9", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"41 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=41, label="8_bit__WFQ_#9", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d" [color=lightblue, id=42, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]", style=filled, type=conv2d]; +"43 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/RELU" [id=43, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]", style=filled, type=RELU]; +"44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=44, label="8_bit__AFQ_#10", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"45 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d" [id=45, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]", style=filled, type=max_pool2d]; +"46 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=46, label="4_bit__AFQ_#3", scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"47 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=47, label="8_bit__WFQ_#3", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d" [color=lightblue, id=48, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]", style=filled, type=conv2d]; +"49 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/RELU" [id=49, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]", style=filled, type=RELU]; +"50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=50, label="4_bit__AFQ_#11", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"51 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=51, label="8_bit__WFQ_#11", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d" [color=lightblue, id=52, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]", style=filled, type=conv2d]; +"53 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/RELU" [id=53, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]", style=filled, type=RELU]; +"54 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=54, label="4_bit__AFQ_#12", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"55 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=55, label="4_bit__WFQ_#12", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d" [color=lightblue, id=56, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]", style=filled, type=conv2d]; +"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/RELU" [id=57, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]", style=filled, type=RELU]; +"58 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=58, label="8_bit__AFQ_#13", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"59 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]/max_pool2d" [id=59, label=max_pool2d, scope="SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]", style=filled, type=max_pool2d]; +"60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=60, label="2_bit__WFQ_#13", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d" [color=lightblue, id=61, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]", style=filled, type=conv2d]; +"62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/RELU" [id=62, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]", style=filled, type=RELU]; +"63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=63, label="8_bit__AFQ_#14", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"64 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=64, label="2_bit__WFQ_#14", scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d" [color=lightblue, id=65, label=conv2d, scope="SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]", style=filled, type=conv2d]; +"66 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/RELU" [id=66, label=RELU, scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]", style=filled, type=RELU]; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=67, label="8_bit__AFQ_#15", scope="SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"68 SSD_VGG/L2Norm[L2Norm]/div" [id=68, label=div, scope="SSD_VGG/L2Norm[L2Norm]", style=filled, type=div]; +"69 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=69, label="8_bit__AFQ_#2", scope="SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"70 SSD_VGG/L2Norm[L2Norm]/__rmul__" [id=70, label=__rmul__, scope="SSD_VGG/L2Norm[L2Norm]", style=filled, type=__rmul__]; +"71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=71, label="4_bit__AFQ_#1", scope="SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"72 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=72, label="8_bit__WFQ_#15", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d" [color=lightblue, id=73, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]", style=filled, type=conv2d]; +"74 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/RELU" [id=74, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[1]", style=filled, type=RELU]; +"75 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=75, label="4_bit__AFQ_#24", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"76 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=76, label="8_bit__WFQ_#24", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d" [color=lightblue, id=77, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]", style=filled, type=conv2d]; +"78 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/RELU" [id=78, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[3]", style=filled, type=RELU]; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=79, label="8_bit__AFQ_#25", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"80 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=80, label="8_bit__WFQ_#25", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d" [color=lightblue, id=81, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]", style=filled, type=conv2d]; +"82 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/RELU" [id=82, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[5]", style=filled, type=RELU]; +"83 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=83, label="4_bit__AFQ_#26", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"84 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=84, label="8_bit__WFQ_#26", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d" [color=lightblue, id=85, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]", style=filled, type=conv2d]; +"86 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/RELU" [id=86, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[7]", style=filled, type=RELU]; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" [color=red, id=87, label="4_bit__AFQ_#27", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"88 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=88, label="8_bit__WFQ_#27", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d" [color=lightblue, id=89, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]", style=filled, type=conv2d]; +"90 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/RELU" [id=90, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[9]", style=filled, type=RELU]; +"91 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=91, label="8_bit__AFQ_#28", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"92 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=92, label="4_bit__WFQ_#28", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d" [color=lightblue, id=93, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]", style=filled, type=conv2d]; +"94 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/RELU" [id=94, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[11]", style=filled, type=RELU]; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=95, label="8_bit__AFQ_#19", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"96 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=96, label="4_bit__WFQ_#19", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d" [color=lightblue, id=97, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]", style=filled, type=conv2d]; +"98 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/RELU" [id=98, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[13]", style=filled, type=RELU]; +"99 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=99, label="8_bit__AFQ_#20", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"100 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=100, label="8_bit__WFQ_#20", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d" [color=lightblue, id=101, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]", style=filled, type=conv2d]; +"102 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/RELU" [id=102, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[15]", style=filled, type=RELU]; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=103, label="8_bit__AFQ_#21", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"104 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=104, label="8_bit__WFQ_#21", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d" [color=lightblue, id=105, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]", style=filled, type=conv2d]; +"106 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/RELU" [id=106, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[17]", style=filled, type=RELU]; +"107 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=107, label="8_bit__AFQ_#22", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=108, label="4_bit__WFQ_#22", scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d" [color=lightblue, id=109, label=conv2d, scope="SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]", style=filled, type=conv2d]; +"110 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/RELU" [id=110, label=RELU, scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[19]", style=filled, type=RELU]; +"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize" [color=green, id=111, label="8_bit__AFQ_#23", scope="SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer", style=filled, type=asymmetric_quantize]; +"112 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=112, label="8_bit__WFQ_#1", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=113, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"114 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=114, label="4_bit__WFQ_#1", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=115, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"116 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=116, label="8_bit__WFQ_#15", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=117, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"118 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=purple, id=118, label="2_bit__WFQ_#15", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=119, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"120 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=120, label="4_bit__WFQ_#25", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=121, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"122 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=122, label="8_bit__WFQ_#25", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=123, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"124 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=124, label="4_bit__WFQ_#27", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=125, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"126 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=126, label="8_bit__WFQ_#27", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=127, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"128 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=128, label="4_bit__WFQ_#19", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=129, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"130 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=130, label="4_bit__WFQ_#19", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=131, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"132 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=red, id=132, label="4_bit__WFQ_#21", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=133, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"134 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=134, label="8_bit__WFQ_#21", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=135, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=136, label="8_bit__WFQ_#23", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d" [color=lightblue, id=137, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]", style=filled, type=conv2d]; +"138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" [color=green, id=138, label="8_bit__WFQ_#23", scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]", style=filled, type=symmetric_quantize]; +"139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d" [color=lightblue, id=139, label=conv2d, scope="SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]", style=filled, type=conv2d]; +"140 SSD_VGG/SSDDetectionOutput[detection_head]/cat" [id=140, label=cat, scope="SSD_VGG/SSDDetectionOutput[detection_head]", style=filled, type=cat]; +"141 SSD_VGG/SSDDetectionOutput[detection_head]/cat" [id=141, label=cat, scope="SSD_VGG/SSDDetectionOutput[detection_head]", style=filled, type=cat]; +"142 SSD_VGG/SSDDetectionOutput[detection_head]/softmax" [id=142, label=softmax, scope="SSD_VGG/SSDDetectionOutput[detection_head]", style=filled, type=softmax]; +"0 /nncf_model_input" -> "1 AsymmetricQuantizer/asymmetric_quantize"; +"1 AsymmetricQuantizer/asymmetric_quantize" -> "3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d"; +"2 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d"; +"3 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[0]/conv2d" -> "4 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/RELU"; +"4 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/RELU" -> "5 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize"; +"5 SSD_VGG/MultiOutputSequential[basenet]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" -> "7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d"; +"6 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d"; +"7 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[2]/conv2d" -> "8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/RELU"; +"8 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/RELU" -> "9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize"; +"9 SSD_VGG/MultiOutputSequential[basenet]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "10 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]/max_pool2d"; +"10 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[4]/max_pool2d" -> "12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d"; +"11 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d"; +"12 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[5]/conv2d" -> "13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/RELU"; +"13 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/RELU" -> "14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer/asymmetric_quantize"; +"14 SSD_VGG/MultiOutputSequential[basenet]/ReLU[6]/AsymmetricQuantizer/asymmetric_quantize" -> "16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d"; +"15 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d"; +"16 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[7]/conv2d" -> "17 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/RELU"; +"17 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/RELU" -> "18 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer/asymmetric_quantize"; +"18 SSD_VGG/MultiOutputSequential[basenet]/ReLU[8]/AsymmetricQuantizer/asymmetric_quantize" -> "19 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]/max_pool2d"; +"19 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[9]/max_pool2d" -> "21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d"; +"20 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d"; +"21 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[10]/conv2d" -> "22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/RELU"; +"22 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/RELU" -> "23 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize"; +"23 SSD_VGG/MultiOutputSequential[basenet]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d"; +"24 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d"; +"25 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[12]/conv2d" -> "26 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/RELU"; +"26 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/RELU" -> "27 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize"; +"27 SSD_VGG/MultiOutputSequential[basenet]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" -> "29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d"; +"28 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d"; +"29 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[14]/conv2d" -> "30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/RELU"; +"30 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/RELU" -> "31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize"; +"31 SSD_VGG/MultiOutputSequential[basenet]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "32 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]/max_pool2d"; +"32 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[16]/max_pool2d" -> "34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d"; +"33 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d"; +"34 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[17]/conv2d" -> "35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/RELU"; +"35 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/RELU" -> "36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer/asymmetric_quantize"; +"36 SSD_VGG/MultiOutputSequential[basenet]/ReLU[18]/AsymmetricQuantizer/asymmetric_quantize" -> "38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d"; +"37 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d"; +"38 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[19]/conv2d" -> "39 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/RELU"; +"39 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/RELU" -> "40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer/asymmetric_quantize"; +"40 SSD_VGG/MultiOutputSequential[basenet]/ReLU[20]/AsymmetricQuantizer/asymmetric_quantize" -> "42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d"; +"41 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d"; +"42 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[21]/conv2d" -> "43 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/RELU"; +"43 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/RELU" -> "44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize"; +"44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize" -> "45 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d"; +"44 SSD_VGG/MultiOutputSequential[basenet]/ReLU[22]/AsymmetricQuantizer/asymmetric_quantize" -> "68 SSD_VGG/L2Norm[L2Norm]/div"; +"45 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/max_pool2d" -> "46 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer/asymmetric_quantize"; +"46 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[23]/AsymmetricQuantizer/asymmetric_quantize" -> "48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d"; +"47 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d"; +"48 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[24]/conv2d" -> "49 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/RELU"; +"49 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/RELU" -> "50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer/asymmetric_quantize"; +"50 SSD_VGG/MultiOutputSequential[basenet]/ReLU[25]/AsymmetricQuantizer/asymmetric_quantize" -> "52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d"; +"51 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d"; +"52 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[26]/conv2d" -> "53 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/RELU"; +"53 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/RELU" -> "54 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer/asymmetric_quantize"; +"54 SSD_VGG/MultiOutputSequential[basenet]/ReLU[27]/AsymmetricQuantizer/asymmetric_quantize" -> "56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d"; +"55 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d"; +"56 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[28]/conv2d" -> "57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/RELU"; +"57 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/RELU" -> "58 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer/asymmetric_quantize"; +"58 SSD_VGG/MultiOutputSequential[basenet]/ReLU[29]/AsymmetricQuantizer/asymmetric_quantize" -> "59 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]/max_pool2d"; +"59 SSD_VGG/MultiOutputSequential[basenet]/MaxPool2d[30]/max_pool2d" -> "61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d"; +"60 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d"; +"61 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[31]/conv2d" -> "62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/RELU"; +"62 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/RELU" -> "63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer/asymmetric_quantize"; +"63 SSD_VGG/MultiOutputSequential[basenet]/ReLU[32]/AsymmetricQuantizer/asymmetric_quantize" -> "65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d"; +"64 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d"; +"65 SSD_VGG/MultiOutputSequential[basenet]/NNCFConv2d[33]/conv2d" -> "66 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/RELU"; +"66 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/RELU" -> "67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize"; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" -> "73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d"; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" -> "117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d"; +"67 SSD_VGG/MultiOutputSequential[basenet]/ReLU[34]/AsymmetricQuantizer/asymmetric_quantize" -> "119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d"; +"68 SSD_VGG/L2Norm[L2Norm]/div" -> "69 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize"; +"69 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" -> "70 SSD_VGG/L2Norm[L2Norm]/__rmul__"; +"70 SSD_VGG/L2Norm[L2Norm]/__rmul__" -> "71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize"; +"71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" -> "113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d"; +"71 SSD_VGG/L2Norm[L2Norm]/AsymmetricQuantizer/asymmetric_quantize" -> "115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d"; +"72 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d"; +"73 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[0]/conv2d" -> "74 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/RELU"; +"74 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/RELU" -> "75 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize"; +"75 SSD_VGG/MultiOutputSequential[extras]/ReLU[1]/AsymmetricQuantizer/asymmetric_quantize" -> "77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d"; +"76 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d"; +"77 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[2]/conv2d" -> "78 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/RELU"; +"78 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/RELU" -> "79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize"; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d"; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d"; +"79 SSD_VGG/MultiOutputSequential[extras]/ReLU[3]/AsymmetricQuantizer/asymmetric_quantize" -> "123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d"; +"80 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d"; +"81 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[4]/conv2d" -> "82 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/RELU"; +"82 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/RELU" -> "83 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer/asymmetric_quantize"; +"83 SSD_VGG/MultiOutputSequential[extras]/ReLU[5]/AsymmetricQuantizer/asymmetric_quantize" -> "85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d"; +"84 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d"; +"85 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[6]/conv2d" -> "86 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/RELU"; +"86 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/RELU" -> "87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize"; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" -> "89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d"; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" -> "125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d"; +"87 SSD_VGG/MultiOutputSequential[extras]/ReLU[7]/AsymmetricQuantizer/asymmetric_quantize" -> "127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d"; +"88 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d"; +"89 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[8]/conv2d" -> "90 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/RELU"; +"90 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/RELU" -> "91 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer/asymmetric_quantize"; +"91 SSD_VGG/MultiOutputSequential[extras]/ReLU[9]/AsymmetricQuantizer/asymmetric_quantize" -> "93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d"; +"92 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d"; +"93 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[10]/conv2d" -> "94 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/RELU"; +"94 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/RELU" -> "95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize"; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d"; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d"; +"95 SSD_VGG/MultiOutputSequential[extras]/ReLU[11]/AsymmetricQuantizer/asymmetric_quantize" -> "131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d"; +"96 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d"; +"97 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[12]/conv2d" -> "98 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/RELU"; +"98 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/RELU" -> "99 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize"; +"99 SSD_VGG/MultiOutputSequential[extras]/ReLU[13]/AsymmetricQuantizer/asymmetric_quantize" -> "101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d"; +"100 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d"; +"101 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[14]/conv2d" -> "102 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/RELU"; +"102 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/RELU" -> "103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize"; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d"; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d"; +"103 SSD_VGG/MultiOutputSequential[extras]/ReLU[15]/AsymmetricQuantizer/asymmetric_quantize" -> "135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d"; +"104 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d"; +"105 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[16]/conv2d" -> "106 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/RELU"; +"106 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/RELU" -> "107 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer/asymmetric_quantize"; +"107 SSD_VGG/MultiOutputSequential[extras]/ReLU[17]/AsymmetricQuantizer/asymmetric_quantize" -> "109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d"; +"108 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d"; +"109 SSD_VGG/MultiOutputSequential[extras]/NNCFConv2d[18]/conv2d" -> "110 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/RELU"; +"110 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/RELU" -> "111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize"; +"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize" -> "137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d"; +"111 SSD_VGG/MultiOutputSequential[extras]/ReLU[19]/AsymmetricQuantizer/asymmetric_quantize" -> "139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d"; +"112 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d"; +"113 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"114 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d"; +"115 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[0]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"116 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d"; +"117 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"118 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d"; +"119 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[1]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"120 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d"; +"121 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"122 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d"; +"123 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[2]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"124 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d"; +"125 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"126 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d"; +"127 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[3]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"128 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d"; +"129 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"130 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d"; +"131 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[4]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"132 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d"; +"133 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"134 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d"; +"135 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[5]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"136 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d"; +"137 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[loc]/conv2d" -> "140 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"138 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize" -> "139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d"; +"139 SSD_VGG/SSDDetectionOutput[detection_head]/ModuleList[heads]/SSDHead[6]/NNCFConv2d[conf]/conv2d" -> "141 SSD_VGG/SSDDetectionOutput[detection_head]/cat"; +"141 SSD_VGG/SSDDetectionOutput[detection_head]/cat" -> "142 SSD_VGG/SSDDetectionOutput[detection_head]/softmax"; +} diff --git a/tests/quantization/test_precision_init.py b/tests/quantization/test_precision_init.py index 17abb9978ac..da7eed4dd6d 100644 --- a/tests/quantization/test_precision_init.py +++ b/tests/quantization/test_precision_init.py @@ -23,6 +23,7 @@ import torch.nn as nn import torch.utils.data from functools import partial +from random import random from torch.utils import model_zoo from torchvision.models import MobileNetV2, mobilenet_v2, resnet50, inception_v3 from torchvision.transforms import transforms @@ -56,7 +57,7 @@ create_mock_dataloader, BasicConvTestModel from tests.quantization.test_quantization_helpers import compare_multi_gpu_dump, \ get_quantization_config_without_range_init, distributed_init_test_default, post_compression_test_distr_init, \ - get_squeezenet_quantization_config + get_squeezenet_quantization_config, create_rank_dataloader from tests.test_compressed_graph import check_graph # pylint:disable=unused-import @@ -104,12 +105,10 @@ def compare_with_ref_if_exists(actual_state, path_to_ref): json.dump(actual_state, f) -class HAWQConfigBuilder: - def __init__(self, config_creator_fn: Callable = None, batch_size=10, num_data_points=100, image_size=10): +class BaseConfigBuilder: + def __init__(self, config_creator_fn: Callable = None): if config_creator_fn: self._config = config_creator_fn() - else: - self._config = self.create_hawq_test_config(batch_size, num_data_points, image_size) self._options: Dict[str, str] = OrderedDict() self._extra_params: str = '' @@ -118,17 +117,6 @@ def with_ratio(self, ratio: float): self._options['ratio'] = str(ratio) return self - def _set_bitwidth_assignment_mode(self, mode: BitwidthAssignmentMode): - self._config['compression']['initializer']['precision']['bitwidth_assignment_mode'] = mode.value - self._options['mode'] = str(mode.value) - return self - - def strict_mode(self): - return self._set_bitwidth_assignment_mode(BitwidthAssignmentMode.STRICT) - - def liberal_mode(self): - return self._set_bitwidth_assignment_mode(BitwidthAssignmentMode.LIBERAL) - def _with_quantizer_setup_type(self, setup_type: QuantizerSetupType): self._config['quantizer_setup_type'] = setup_type.value self._options['setup_type'] = setup_type.value @@ -158,7 +146,7 @@ def _set_target_device(self, config_type: str): return self def for_vpu(self): - return self._set_target_device(HWConfigType.VPU.value).prop_based().strict_mode() + return self._set_target_device(HWConfigType.VPU.value).prop_based() def for_cpu(self): return self._set_target_device(HWConfigType.CPU.value).prop_based() @@ -166,9 +154,6 @@ def for_cpu(self): def for_trial(self): return self._set_target_device('TRIAL').prop_based() - def none_device(self): - self._config["target_device"] = None - def build(self): return self._config @@ -186,6 +171,32 @@ def filename_suffix(self) -> str: ordered_options = OrderedDict(sorted(self._options.items())) return '__'.join(['_'.join([k, v]) for k, v in ordered_options.items()]) + +class HAWQConfigBuilder(BaseConfigBuilder): + def __init__(self, config_creator_fn: Callable = None, batch_size=10, num_data_points=100, image_size=10): + super().__init__(config_creator_fn) + if not config_creator_fn: + self._config = self.create_hawq_test_config(batch_size, num_data_points, image_size) + self.num_data_points = num_data_points + + def _set_bitwidth_assignment_mode(self, mode: BitwidthAssignmentMode): + self._config['compression']['initializer']['precision']['bitwidth_assignment_mode'] = mode.value + self._options['mode'] = str(mode.value) + return self + + def strict_mode(self): + return self._set_bitwidth_assignment_mode(BitwidthAssignmentMode.STRICT) + + def liberal_mode(self): + return self._set_bitwidth_assignment_mode(BitwidthAssignmentMode.LIBERAL) + + def build(self): + return self._config + + def for_vpu(self): + super().for_vpu() + return self.strict_mode() + @staticmethod def create_hawq_test_config(batch_size=10, num_data_points=100, image_size=10): config = get_quantization_config_without_range_init() @@ -235,6 +246,19 @@ def get_avg_traces(model, init_device: str): return torch.randperm(num_traces).to(init_device) + 1 +def check_bitwidth_graph(algo_ctrl, model, path_to_dot, graph_dir): + model = model.cuda() + all_quantizers_per_full_scope = HAWQDebugger.get_all_quantizers_per_full_scope(model) + quantizer_switcher = QuantizersSwitcher(list(all_quantizers_per_full_scope.values())) + # graph may not contain some quantizers (e.g. in staged scenario) + quantizer_switcher.enable_quantizers() + model.rebuild_graph() + groups_of_adjacent_quantizers = GroupsOfAdjacentQuantizers(algo_ctrl) + graph = HAWQDebugger.get_bitwidth_graph(algo_ctrl, model, all_quantizers_per_full_scope, + groups_of_adjacent_quantizers) + check_graph(graph, path_to_dot, graph_dir, sort_dot_graph=False) + + class HAWQTestStruct(NamedTuple): model_creator: Callable[[], nn.Module] = mobilenet_v2 config_builder: HAWQConfigBuilder = HAWQConfigBuilder().prop_based().for_vpu() @@ -245,7 +269,7 @@ def __str__(self): return '_'.join([self.model_creator.__name__, str(self.config_builder)]) -TEST_PARAMS = ( +HAWQ_TEST_PARAMS = ( HAWQTestStruct(config_builder=HAWQConfigBuilder().pattern_based()), HAWQTestStruct(config_builder=HAWQConfigBuilder().staged().pattern_based()), HAWQTestStruct(config_builder=HAWQConfigBuilder().for_trial()), @@ -277,7 +301,7 @@ def __str__(self): ) -@pytest.mark.parametrize('params', TEST_PARAMS, ids=[str(p) for p in TEST_PARAMS]) +@pytest.mark.parametrize('params', HAWQ_TEST_PARAMS, ids=[str(p) for p in HAWQ_TEST_PARAMS]) def test_hawq_precision_init(_seed, dataset_dir, tmp_path, mocker, params): config = params.config_builder.build() model = params.model_creator() @@ -291,17 +315,132 @@ def test_hawq_precision_init(_seed, dataset_dir, tmp_path, mocker, params): mocked_trace = mocker.patch('nncf.quantization.hessian_trace.HessianTraceEstimator.get_average_traces') mocked_trace.return_value = params.avg_traces_creator(model, 'cuda') model, algo_ctrl = create_compressed_model_and_algo_for_test(model, config) - model = model.cuda() - all_quantizers_per_full_scope = HAWQDebugger.get_all_quantizers_per_full_scope(model) - quantizer_switcher = QuantizersSwitcher(list(all_quantizers_per_full_scope.values())) - # graph may not contain some quantizers (e.g. in staged scenario) - quantizer_switcher.enable_quantizers() - model.rebuild_graph() - groups_of_adjacent_quantizers = GroupsOfAdjacentQuantizers(algo_ctrl) - graph = HAWQDebugger.get_bitwidth_graph(algo_ctrl, model, all_quantizers_per_full_scope, - groups_of_adjacent_quantizers) + + path_to_dot = '{}_{}.dot'.format(params.model_creator.__name__, params.config_builder.filename_suffix()) + graph_dir = os.path.join('quantized', 'hawq') + check_bitwidth_graph(algo_ctrl, model, path_to_dot, graph_dir) + + +class AutoQConfigBuilder(BaseConfigBuilder): + def __init__(self, config_creator_fn: Callable = None, batch_size=10, image_size=10, num_channels=3, + num_init_samples=1): + super().__init__(config_creator_fn) + if not config_creator_fn: + self._config = self.create_autoq_test_config(batch_size, image_size, num_channels, + num_init_samples=num_init_samples) + self.for_vpu() + + def eval_subset_ratio(self, eval_subset_ratio): + self._options['eval_subset_ratio'] = str(eval_subset_ratio) + self._config['compression']['initializer']['precision']['eval_subset_ratio'] = eval_subset_ratio + return self + + def iter_number(self, iter_number): + self._options['iter_number'] = str(iter_number) + self._config['compression']['initializer']['precision']['iter_number'] = iter_number + return self + + def warmup_iter_number(self, warmup_iter_number): + self._options['warmup_iter_number'] = str(warmup_iter_number) + self._config['compression']['initializer']['precision']['warmup_iter_number'] = warmup_iter_number + return self + + @staticmethod + def create_autoq_test_config(batch_size=10, image_size=10, num_channels=3, num_init_samples=1): + config = get_quantization_config_without_range_init() + config['input_info'] = { + "sample_size": [batch_size, num_channels, image_size, image_size], + } + config['batch_size'] = batch_size + config['compression'].update({ + 'initializer': { + 'precision': { + "type": "autoq", + "bits": [2, 4, 8], + "iter_number": 2, + "compression_ratio": 0.15, + "eval_subset_ratio": 1.0, + "warmup_iter_number": 1 + }, + 'range': { + 'num_init_samples': num_init_samples + }, + 'batchnorm_adaptation': { + 'num_bn_adaptation_samples': 0, + 'num_bn_forget_samples': 0 + } + }}) + return config + + +class AutoQTestStruct(NamedTuple): + model_creator: Callable[[], nn.Module] = mobilenet_v2 + config_builder: AutoQConfigBuilder = AutoQConfigBuilder().for_vpu() + filename_suffix: str = 'hw_config_vpu' + + def __str__(self): + return '_'.join([self.model_creator.__name__, str(self.config_builder)]) + + +RATIO = 0.4 +AUTOQ_TEST_PARAMS = ( + AutoQTestStruct(config_builder=AutoQConfigBuilder()), + AutoQTestStruct(config_builder=AutoQConfigBuilder().with_ratio(RATIO)), + AutoQTestStruct(config_builder=AutoQConfigBuilder().with_ratio(RATIO).eval_subset_ratio(RATIO)), + AutoQTestStruct(config_builder=AutoQConfigBuilder().eval_subset_ratio(RATIO)), + AutoQTestStruct(model_creator=squeezenet1_1, + config_builder=AutoQConfigBuilder().with_sample_size([1, 3, 224, 224])), + AutoQTestStruct(model_creator=resnet50, + config_builder=AutoQConfigBuilder()), + AutoQTestStruct(model_creator=resnet50, + config_builder=AutoQConfigBuilder().iter_number(4).warmup_iter_number(2)), + AutoQTestStruct(model_creator=resnet50, + config_builder=AutoQConfigBuilder().with_ratio(RATIO)), + AutoQTestStruct(model_creator=resnet50, + config_builder=AutoQConfigBuilder().eval_subset_ratio(RATIO)), + AutoQTestStruct(model_creator=resnet50, + config_builder=AutoQConfigBuilder().with_ratio(RATIO).eval_subset_ratio(RATIO)), + AutoQTestStruct(model_creator=inception_v3, + config_builder=AutoQConfigBuilder().with_sample_size([2, 3, 299, 299]).with_ratio(RATIO)), + AutoQTestStruct(model_creator=inception_v3, + config_builder=AutoQConfigBuilder().with_sample_size([2, 3, 299, 299]). + with_ignored_scope(['Inception3/BasicConv2d[Conv2d_2a_3x3]']).eval_subset_ratio(RATIO)), + AutoQTestStruct(model_creator=ssd_vgg_512_test, + config_builder=AutoQConfigBuilder().with_sample_size([1, 3, 512, 512]).eval_subset_ratio(RATIO)), + AutoQTestStruct(model_creator=ssd_vgg_512_test, + config_builder=AutoQConfigBuilder().with_sample_size([1, 3, 512, 512]).with_ratio(RATIO)), +) + + +@pytest.mark.parametrize('params', AUTOQ_TEST_PARAMS, ids=[str(p) for p in AUTOQ_TEST_PARAMS]) +def test_autoq_precision_init(_seed, dataset_dir, tmp_path, mocker, params): + config = params.config_builder.build() + model = params.model_creator() + config['log_dir'] = str(tmp_path) + + if not dataset_dir: + dataset_dir = str(tmp_path) + train_loader, _ = create_test_dataloaders(config, dataset_dir) + + from nncf.automl.agent.ddpg.ddpg import DDPG + random_action_spy = mocker.spy(DDPG, 'random_action') + select_action_spy = mocker.spy(DDPG, 'select_action') + + config = register_default_init_args(config, train_loader=train_loader, + autoq_eval_fn=lambda *x: random(), + autoq_eval_loader=train_loader) + model, algo_ctrl = create_compressed_model_and_algo_for_test(model, config) + + bw_init_config = config['compression']['initializer']['precision'] + learning_iter_number = bw_init_config['iter_number'] - bw_init_config['warmup_iter_number'] + n_quantizer = len(algo_ctrl.all_quantizations) + + assert random_action_spy.call_count == bw_init_config['warmup_iter_number'] * n_quantizer + assert select_action_spy.call_count == learning_iter_number * (n_quantizer+1) + bw_init_config['warmup_iter_number'] + path_to_dot = '{}_{}.dot'.format(params.model_creator.__name__, params.config_builder.filename_suffix()) - check_graph(graph, path_to_dot, os.path.join('quantized', 'hawq'), sort_dot_graph=False) + graph_dir = os.path.join('quantized', 'autoq') + check_bitwidth_graph(algo_ctrl, model, path_to_dot, graph_dir) def test_hawq_hw_vpu_config_e2e(_seed, dataset_dir, tmp_path): @@ -492,11 +631,13 @@ def get_path_to_bitwidth_dump(tmp_path, rank): def hawq_dumping_worker(gpu, ngpus_per_node, config, tmp_path): - data_loader = distributed_init_test_default(gpu, ngpus_per_node, config) + distributed_init_test_default(gpu, ngpus_per_node, config) + data_loader = create_rank_dataloader(config, gpu) model = safe_thread_call(partial(mobilenet_v2, pretrained=True)) model.eval() criterion = torch.nn.MSELoss().cuda(config.gpu) - config = register_default_init_args(config, data_loader, criterion) + config = register_default_init_args(config, data_loader, criterion, + autoq_eval_fn=lambda *x: 0, autoq_eval_loader=data_loader) quant_model, compression_ctrl = create_compressed_model_and_algo_for_test(model, config) quant_model = post_compression_test_distr_init(compression_ctrl, config, ngpus_per_node, quant_model) @@ -509,10 +650,10 @@ def hawq_dumping_worker(gpu, ngpus_per_node, config, tmp_path): torch.save(act_bitwidth_per_scope, str(out_file_path)) -def test_hawq_broadcast_avg_traces_in_distributed_mode(tmp_path): - num_data_points = 10 - batch_size = 2 - config = HAWQConfigBuilder(batch_size=batch_size, num_data_points=num_data_points, image_size=224).build() +@pytest.mark.parametrize('config_builder', [HAWQConfigBuilder(batch_size=2, num_data_points=10).for_trial(), + AutoQConfigBuilder(batch_size=2).for_trial()]) +def test_can_broadcast_initialized_precisions_in_distributed_mode(config_builder, tmp_path): + config = config_builder.build() ngpus_per_node = torch.cuda.device_count() config.world_size = ngpus_per_node torch.multiprocessing.spawn(hawq_dumping_worker, diff --git a/tests/quantization/test_quantization_helpers.py b/tests/quantization/test_quantization_helpers.py index aa7d0015979..6333dd26312 100644 --- a/tests/quantization/test_quantization_helpers.py +++ b/tests/quantization/test_quantization_helpers.py @@ -85,14 +85,16 @@ def distributed_init_test_default(gpu, ngpus_per_node, config): config.rank = gpu config.distributed = True - torch.distributed.init_process_group(backend="nccl", init_method='tcp://127.0.0.1:8899', + torch.distributed.init_process_group(backend="nccl", init_method='tcp://127.0.0.1:8199', world_size=config.world_size, rank=config.rank) + +def create_rank_dataloader(config, rank): input_infos_list = create_input_infos(config) input_sample_size = input_infos_list[0].shape - data_loader = torch.utils.data.DataLoader(RankDatasetMock(input_sample_size[1:], config.rank), + data_loader = torch.utils.data.DataLoader(RankDatasetMock(input_sample_size[1:], rank), batch_size=3, - num_workers=0, # workaround + num_workers=0, # workaround shuffle=False, drop_last=True) return data_loader diff --git a/tests/quantization/test_range_init.py b/tests/quantization/test_range_init.py index f8de38d7536..73c740aa3e3 100644 --- a/tests/quantization/test_range_init.py +++ b/tests/quantization/test_range_init.py @@ -36,13 +36,15 @@ from nncf.structures import QuantizationRangeInitArgs from nncf.utils import get_all_modules_by_type, safe_thread_call from tests.quantization.test_quantization_helpers import compare_multi_gpu_dump, \ - get_squeezenet_quantization_config, distributed_init_test_default, post_compression_test_distr_init + get_squeezenet_quantization_config, distributed_init_test_default, post_compression_test_distr_init, \ + create_rank_dataloader from tests.helpers import TwoConvTestModel, get_empty_config, \ create_compressed_model_and_algo_for_test, create_mock_dataloader, BasicConvTestModel def scale_signed_dumping_worker(gpu, ngpus_per_node, config, tmp_path): - data_loader = distributed_init_test_default(gpu, ngpus_per_node, config) + distributed_init_test_default(gpu, ngpus_per_node, config) + data_loader = create_rank_dataloader(config, gpu) model = safe_thread_call(partial(squeezenet1_1, pretrained=True)) config.register_extra_structs([QuantizationRangeInitArgs(data_loader)]) diff --git a/tests/test_init_data_loader.py b/tests/test_init_data_loader.py new file mode 100644 index 00000000000..4d53e55e70a --- /dev/null +++ b/tests/test_init_data_loader.py @@ -0,0 +1,58 @@ +""" + Copyright (c) 2021 Intel Corporation + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import pytest +from math import ceil +from tests.helpers import get_empty_config, create_mock_dataloader + +from nncf.initialization import PartialDataLoader + +N_SAMPLE = 10 +VALID_RATIO = [0.0, 0.05, 0.2, 0.51, 0.89, 1.0] +INVALID_RATIO = ['string', '0.5', -17, -0.01, 1.01, 5, 100] + + +def create_regular_dataloader(): + return create_mock_dataloader(config=get_empty_config(), num_samples=N_SAMPLE) + + +def test_can_create_partial_dataloader__with_defaults(): + dataloader = create_regular_dataloader() + partial_dataloader = PartialDataLoader(dataloader) + assert partial_dataloader.data_loader is dataloader + assert partial_dataloader.batch_size == 1 + assert len(partial_dataloader) == N_SAMPLE + + +@pytest.mark.parametrize('invalid_ratio', INVALID_RATIO, ids=[str(r) for r in INVALID_RATIO]) +def test_partial_dataloader__with_invalid_ratio(invalid_ratio): + dataloader = create_regular_dataloader() + with pytest.raises((ValueError, TypeError)): + _ = PartialDataLoader(dataloader, iter_ratio=invalid_ratio) + + +@pytest.mark.parametrize('valid_ratio', VALID_RATIO, ids=[str(r) for r in VALID_RATIO]) +def test_partial_dataloader__with_valid_ratio(valid_ratio): + dataloader = create_regular_dataloader() + partial_dataloader = PartialDataLoader(dataloader, iter_ratio=valid_ratio) + truth_num_batch = ceil(valid_ratio * ceil(N_SAMPLE/dataloader.batch_size)) + assert len(partial_dataloader) == truth_num_batch + + i = 0 + for i, _ in enumerate(partial_dataloader): + pass + + if valid_ratio == 0: + assert truth_num_batch == 0 + else: + assert (i + 1) == truth_num_batch diff --git a/tests/test_sanity_sample.py b/tests/test_sanity_sample.py index 6db1150998f..d9ba4367618 100644 --- a/tests/test_sanity_sample.py +++ b/tests/test_sanity_sample.py @@ -20,6 +20,7 @@ import time from enum import Enum, auto from pathlib import Path +from typing import Dict import os import pytest @@ -32,6 +33,7 @@ from examples.common.utils import get_name, is_staged_quantization from nncf.compression_method_api import CompressionLevel from nncf.config import NNCFConfig +from nncf.quantization.layers import QuantizerConfig from tests.conftest import EXAMPLES_DIR, PROJECT_ROOT, TEST_ROOT @@ -485,28 +487,32 @@ class SampleType(Enum): class TestCaseDescriptor: config_name: str - config_path: Path + quantization_algo_params: Dict = {} sample_type: SampleType dataset_dir: Path dataset_name: str is_real_dataset: bool = False batch_size: int - batch_size_init: int = None - num_weights_to_init: int + n_weight_quantizers: int + n_activation_quantizers: int def batch(self, batch_size: int): self.batch_size = batch_size return self - def batch_for_init(self, batch_size_init: int): - self.batch_size_init = batch_size_init - return self + def get_config_path(self): + return TEST_ROOT.joinpath("data", "configs", "hawq", self.config_name) def config(self, config_name: str): - self.config_path = TEST_ROOT.joinpath("data", "configs", "hawq", config_name) self.config_name = config_name return self + def staged(self): + self.quantization_algo_params = { + "activations_quant_start_epoch": 0 + } + return self + def sample(self, sample_type: SampleType): self.sample_type = sample_type return self @@ -517,100 +523,214 @@ def real_dataset(self, dataset_name: str): return self def mock_dataset(self, dataset_name: str): + self.dataset_name = dataset_name self.dataset_dir = TEST_ROOT.joinpath("data", "mock_datasets", dataset_name) return self - def num_weights(self, n: int): - self.num_weights_to_init = n + def num_weight_quantizers(self, n: int): + self.n_weight_quantizers = n + return self + + def num_activation_quantizers(self, n: int): + self.n_activation_quantizers = n + return self + + def __str__(self): + return '_'.join([self.config_name, 'staged' if self.quantization_algo_params else '']) + + def get_config_update(self) -> Dict: + sample_params = self.get_sample_params() + return { + **sample_params, + 'target_device': 'VPU', + 'compression': { + 'algorithm': 'quantization', + 'initializer': { + 'precision': self.get_precision_section(), + 'range': { + "num_init_samples": 2 + }, + "batchnorm_adaptation": { + "num_bn_adaptation_samples": 1, + "num_bn_forget_samples": 1 + } + }, + 'params': self.quantization_algo_params, + } + } + + def get_precision_section(self) -> Dict: + raise NotImplementedError + + def get_sample_params(self) -> Dict: + return {"dataset": self.dataset_name} + + def setup_spy(self, mocker): + raise NotImplementedError + + def validate_spy(self): + raise NotImplementedError + + +class HAWQDescriptor(TestCaseDescriptor): + batch_size_init: int = 0 + set_chosen_config_spy = None + hessian_trace_estimator_spy = None + + def batch_for_init(self, batch_size_init: int): + self.batch_size_init = batch_size_init return self + def get_sample_params(self): + result = super().get_sample_params() + result.update({'batch_size_init': self.batch_size_init} if self.batch_size_init else {}) + return result + + def get_precision_section(self) -> Dict: + return {"type": "hawq", + "num_data_points": 3, + "iter_number": 1} + def __str__(self): - return '_'.join([self.config_name, ]) + bs = f'_bs{self.batch_size_init}' if self.batch_size_init else '' + return super().__str__() + '_hawq' + bs + + def setup_spy(self, mocker): + from nncf.quantization.init_precision import HAWQPrecisionInitializer + self.set_chosen_config_spy = mocker.spy(HAWQPrecisionInitializer, "set_chosen_config") + from nncf.quantization.hessian_trace import HessianTraceEstimator + self.hessian_trace_estimator_spy = mocker.spy(HessianTraceEstimator, "__init__") + + def validate_spy(self): + bitwidth_list = self.set_chosen_config_spy.call_args[0][1] + assert len(bitwidth_list) == self.n_weight_quantizers + # with default compression ratio = 1.5 all precisions should be different from the default one + assert set(bitwidth_list) != {QuantizerConfig().bits} + + init_data_loader = self.hessian_trace_estimator_spy.call_args[0][5] + expected_batch_size = self.batch_size_init if self.batch_size_init else self.batch_size + assert init_data_loader.batch_size == expected_batch_size + + +class AutoQDescriptor(TestCaseDescriptor): + subset_ratio_: float = 1.0 + + def subset_ratio(self, subset_ratio_: float): + self.subset_ratio_ = subset_ratio_ + return self + + def get_precision_section(self) -> Dict: + return {"type": "autoq", + "bits": [2, 4, 8], + "iter_number": 2, + "compression_ratio": 0.15, + "eval_subset_ratio": self.subset_ratio_} + + def __str__(self): + sr = f'_sr{self.subset_ratio_}' if self.subset_ratio_ else '' + return super().__str__() + '_autoq' + sr + + def setup_spy(self, mocker): + from nncf.quantization.init_precision import AutoQPrecisionInitializer + self.set_chosen_config_spy = mocker.spy(AutoQPrecisionInitializer, "set_chosen_config") + + def validate_spy(self): + qid_bitwidth_map = self.set_chosen_config_spy.call_args[0][1] + assert len(qid_bitwidth_map) == self.n_weight_quantizers + self.n_activation_quantizers + assert set(qid_bitwidth_map.values()) != {QuantizerConfig().bits} + + +def resnet18_desc(x: TestCaseDescriptor): + return x.config("resnet18_cifar10_mixed_int.json").sample(SampleType.CLASSIFICATION). \ + mock_dataset('mock_32x32').batch(3).num_weight_quantizers(21).num_activation_quantizers(27) + + +def inception_v3_desc(x: TestCaseDescriptor): + return x.config("inception_v3_cifar10_mixed_int.json").sample(SampleType.CLASSIFICATION). \ + mock_dataset('mock_32x32').batch(3).num_weight_quantizers(95).num_activation_quantizers(105) + + +def ssd300_vgg_desc(x: TestCaseDescriptor): + return x.config("ssd300_vgg_voc_mixed_int.json").sample(SampleType.OBJECT_DETECTION). \ + mock_dataset('voc').batch(3).num_weight_quantizers(35).num_activation_quantizers(27) + + +def unet_desc(x: TestCaseDescriptor): + return x.config("unet_camvid_mixed_int.json").sample(SampleType.SEMANTIC_SEGMENTATION). \ + mock_dataset('camvid').batch(3).num_weight_quantizers(23).num_activation_quantizers(23) + + +def icnet_desc(x: TestCaseDescriptor): + return x.config("icnet_camvid_mixed_int.json").sample(SampleType.SEMANTIC_SEGMENTATION). \ + mock_dataset('camvid').batch(3).num_weight_quantizers(64).num_activation_quantizers(81) TEST_CASE_DESCRIPTORS = [ - TestCaseDescriptor(). - config("inception_v3_cifar10_mixed_int.json"). - sample(SampleType.CLASSIFICATION).real_dataset('cifar10').batch(2).num_weights(95), - TestCaseDescriptor(). - config("inception_v3_cifar10_mixed_int_staged.json"). - sample(SampleType.CLASSIFICATION).real_dataset('cifar10').batch(2).num_weights(95), - TestCaseDescriptor(). - config("resnet18_cifar10_mixed_int.json"). - sample(SampleType.CLASSIFICATION).real_dataset('cifar10').batch(2).num_weights(21), - TestCaseDescriptor(). - config("resnet18_cifar10_mixed_int_staged.json"). - sample(SampleType.CLASSIFICATION).real_dataset('cifar10').batch(2).num_weights(21), - TestCaseDescriptor(). - config("resnet18_cifar10_mixed_int.json"). - sample(SampleType.CLASSIFICATION).real_dataset('cifar10').batch(3).num_weights(21).batch_for_init(2), - TestCaseDescriptor(). - config("resnet18_cifar10_mixed_int_staged.json"). - sample(SampleType.CLASSIFICATION).real_dataset('cifar10').batch(3).num_weights(21).batch_for_init(2), - TestCaseDescriptor(). - config("ssd300_vgg_voc_mixed_int.json"). - sample(SampleType.OBJECT_DETECTION).mock_dataset('voc').batch(2).num_weights(35), - TestCaseDescriptor(). - config("ssd300_vgg_voc_mixed_int.json"). - sample(SampleType.OBJECT_DETECTION).mock_dataset('voc').batch(3).num_weights(35).batch_for_init(2), - TestCaseDescriptor(). - config("unet_camvid_mixed_int.json"). - sample(SampleType.SEMANTIC_SEGMENTATION).mock_dataset('camvid').batch(2).num_weights(23), - TestCaseDescriptor(). - config("icnet_camvid_mixed_int.json"). - sample(SampleType.SEMANTIC_SEGMENTATION).mock_dataset('camvid').batch(2).num_weights(64), - TestCaseDescriptor(). - config("unet_camvid_mixed_int.json"). - sample(SampleType.SEMANTIC_SEGMENTATION).mock_dataset('camvid').batch(3).num_weights(23).batch_for_init(2), + inception_v3_desc(HAWQDescriptor()), + inception_v3_desc(HAWQDescriptor()).staged(), + resnet18_desc(HAWQDescriptor()), + resnet18_desc(HAWQDescriptor()).staged(), + resnet18_desc(HAWQDescriptor()).batch_for_init(2), + resnet18_desc(HAWQDescriptor()).batch_for_init(2).staged(), + ssd300_vgg_desc(HAWQDescriptor()), + ssd300_vgg_desc(HAWQDescriptor()).batch_for_init(2), + unet_desc(HAWQDescriptor()), + unet_desc(HAWQDescriptor()).batch_for_init(2), + icnet_desc(HAWQDescriptor()), + inception_v3_desc(AutoQDescriptor()).batch(2), + inception_v3_desc(AutoQDescriptor()).staged(), + resnet18_desc(AutoQDescriptor()).batch(2), + resnet18_desc(AutoQDescriptor()).batch(2).staged(), + resnet18_desc(AutoQDescriptor()).subset_ratio(0.2).batch(2), + resnet18_desc(AutoQDescriptor()).subset_ratio(0.2).staged(), + ssd300_vgg_desc(AutoQDescriptor()), + unet_desc(AutoQDescriptor()), + icnet_desc(AutoQDescriptor()) ] @pytest.fixture(params=TEST_CASE_DESCRIPTORS, ids=[str(d) for d in TEST_CASE_DESCRIPTORS]) -def hawq_config(request, dataset_dir): +def desc(request, dataset_dir): desc: TestCaseDescriptor = request.param + config_path = desc.get_config_path() + with config_path.open() as file: + json_config = json.load(file) + json_config.update(desc.get_config_update()) + desc.config = json_config if desc.is_real_dataset: desc.dataset_dir = Path( dataset_dir if dataset_dir else os.path.join(tempfile.gettempdir(), desc.dataset_name)) return desc -def test_hawq_init(hawq_config, tmp_path, mocker): +def test_precision_init(desc: TestCaseDescriptor, tmp_path, mocker): + config_factory = ConfigFactory(desc.config, tmp_path / 'config.json') args = { - "--data": str(hawq_config.dataset_dir), - "--config": str(hawq_config.config_path), + "--data": str(desc.dataset_dir), + "--config": config_factory.serialize(), "--log-dir": tmp_path, - "--batch-size": hawq_config.batch_size, + "--batch-size": desc.batch_size, "--workers": 0, # Workaround for the PyTorch MultiProcessingDataLoader issue } - batch_size_for_init = hawq_config.batch_size_init - if batch_size_for_init: - args["--batch-size-init"] = batch_size_for_init command_line = " ".join(f'{key} {val}' for key, val in args.items()) - # to prevent starting a not closed mlflow session due to memory leak of config and SafeMLFLow happens with a - # mocked train function - mocker.patch("examples.common.utils.SafeMLFLow") - if hawq_config.sample_type == SampleType.CLASSIFICATION: + # Need to mock SafeMLFLow to prevent starting a not closed mlflow session due to memory leak of config and + # SafeMLFLow, which happens with a mocked train function + if desc.sample_type == SampleType.CLASSIFICATION: import examples.classification.main as sample mocker.patch("examples.classification.staged_quantization_worker.train_staged") mocker.patch("examples.classification.main.train") - elif hawq_config.sample_type == SampleType.SEMANTIC_SEGMENTATION: + mocker.patch("examples.classification.main.SafeMLFLow") + mocker.patch("examples.classification.staged_quantization_worker.SafeMLFLow") + elif desc.sample_type == SampleType.SEMANTIC_SEGMENTATION: import examples.semantic_segmentation.main as sample mocker.patch("examples.semantic_segmentation.main.train") - elif hawq_config.sample_type == SampleType.OBJECT_DETECTION: + mocker.patch("examples.semantic_segmentation.main.SafeMLFLow") + elif desc.sample_type == SampleType.OBJECT_DETECTION: import examples.object_detection.main as sample mocker.patch("examples.object_detection.main.train") - from nncf.quantization.init_precision import HAWQPrecisionInitializer - set_chosen_config_spy = mocker.spy(HAWQPrecisionInitializer, "set_chosen_config") - from nncf.quantization.hessian_trace import HessianTraceEstimator - hessian_trace_estimator_spy = mocker.spy(HessianTraceEstimator, "__init__") + mocker.patch("examples.object_detection.main.SafeMLFLow") + desc.setup_spy(mocker) sample.main(shlex.split(command_line)) - bitwidth_list = set_chosen_config_spy.call_args[0][1] - assert len(bitwidth_list) == hawq_config.num_weights_to_init - # with default compression ratio = 1.5 should be always a mixed precision model - assert len(set(bitwidth_list)) > 1 - - init_data_loader = hessian_trace_estimator_spy.call_args[0][5] - expected_batch_size = batch_size_for_init if batch_size_for_init else hawq_config.batch_size - assert init_data_loader.batch_size == expected_batch_size + desc.validate_spy()